Attachment 147787 Details for Bug 228033 – Preprocessed source

Preprocessed source

ccr13IAy.out (text/plain), 1.47 MB, created by Michele Mazza on 2007-02-09 17:29:10 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Michele Mazza

Created: 2007-02-09 17:29:10 UTC

Size: 1.47 MB

patch

obsolete

>// /usr/libexec/gcc/i386-redhat-linux/4.1.1/cc1plus -quiet -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../build/manual -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../usr/local/include -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../usr/local/include/xercesc -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../usr/local/include/xalanc -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../myxerces/include -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../myxerces/include/xercesc -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../myxalan/include -I/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../../myxalan/include/xalanc -D_GNU_SOURCE -DHAVE_CONFIG_H fmrBasketPricer.c -quiet -dumpbase fmrBasketPricer.c -mtune=generic -ansi -auxbase-strip fmrBasketPricer.o -g -O3 -pedantic -ansi -ftemplate-depth-17 -fno-nonansi-builtins -o - -frandom-seed=0
># 1 "fmrBasketPricer.c"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/src/finance/option//"
># 1 "<built-in>"
># 1 "<command line>"
># 1 "fmrBasketPricer.c"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/option/fmrBasketPricer.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrVisitor.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 1
># 18 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../build/manual/fmr4000fin_config.h" 1
># 19 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 2
># 163 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrAixGcc.h" 1
># 164 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 2
># 176 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h"
># 1 "/usr/include/stdlib.h" 1 3 4
># 25 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 329 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 313 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 314 "/usr/include/sys/cdefs.h" 2 3 4
># 330 "/usr/include/features.h" 2 3 4
># 352 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/gnu/stubs.h" 2 3 4
>
>
># 1 "/usr/include/gnu/stubs-32.h" 1 3 4
># 8 "/usr/include/gnu/stubs.h" 2 3 4
># 353 "/usr/include/features.h" 2 3 4
># 26 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 214 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 34 "/usr/include/stdlib.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 43 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 65 "/usr/include/bits/waitstatus.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 38 "/usr/include/endian.h" 2 3 4
># 66 "/usr/include/bits/waitstatus.h" 2 3 4
>
>union wait
> {
> int w_status;
> struct
> {
>
> unsigned int __w_termsig:7;
> unsigned int __w_coredump:1;
> unsigned int __w_retcode:8;
> unsigned int:16;
>
>
>
>
>
>
>
> } __wait_terminated;
> struct
> {
>
> unsigned int __w_stopval:8;
> unsigned int __w_stopsig:8;
> unsigned int:16;
>
>
>
>
>
>
> } __wait_stopped;
> };
># 44 "/usr/include/stdlib.h" 2 3 4
># 96 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
> {
> int quot;
> int rem;
> } div_t;
>
>
>
>typedef struct
> {
> long int quot;
> long int rem;
> } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
> {
> long long int quot;
> long long int rem;
> } lldiv_t;
>
>
># 140 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) throw () ;
>
>
>
>
>extern double atof (__const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern int atoi (__const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long int atol (__const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__ extern long long int atoll (__const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern double strtod (__const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern float strtof (__const char *__restrict __nptr,
> char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern long double strtold (__const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern long int strtol (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern unsigned long int strtoul (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>__extension__
>extern long long int strtoq (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtouq (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__
>extern long long int strtoll (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtoull (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
># 236 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/xlocale.h" 1 3 4
># 28 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
> struct locale_data *__locales[13];
>
>
> const unsigned short int *__ctype_b;
> const int *__ctype_tolower;
> const int *__ctype_toupper;
>
>
> const char *__names[13];
>} *__locale_t;
># 237 "/usr/include/stdlib.h" 2 3 4
>
>
>
>extern long int strtol_l (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base,
> __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))) ;
>
>extern unsigned long int strtoul_l (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4))) ;
>
>__extension__
>extern long long int strtoll_l (__const char *__restrict __nptr,
> char **__restrict __endptr, int __base,
> __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4))) ;
>
>__extension__
>extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4))) ;
>
>extern double strtod_l (__const char *__restrict __nptr,
> char **__restrict __endptr, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3))) ;
>
>extern float strtof_l (__const char *__restrict __nptr,
> char **__restrict __endptr, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3))) ;
>
>extern long double strtold_l (__const char *__restrict __nptr,
> char **__restrict __endptr,
> __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3))) ;
>
>
>
>
>
>
>extern double __strtod_internal (__const char *__restrict __nptr,
> char **__restrict __endptr, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>extern float __strtof_internal (__const char *__restrict __nptr,
> char **__restrict __endptr, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>extern long double __strtold_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern long int __strtol_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>__extension__
>extern long long int __strtoll_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>__extension__
>extern unsigned long long int __strtoull_internal (__const char *
> __restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>extern __inline double
>strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
>{
> return __strtod_internal (__nptr, __endptr, 0);
>}
>extern __inline long int
>strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()
>
>{
> return __strtol_internal (__nptr, __endptr, __base, 0);
>}
>extern __inline unsigned long int
>strtoul (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()
>
>{
> return __strtoul_internal (__nptr, __endptr, __base, 0);
>}
>
>
>
>
>extern __inline float
>strtof (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
>{
> return __strtof_internal (__nptr, __endptr, 0);
>}
>
>extern __inline long double
>strtold (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
>{
> return __strtold_internal (__nptr, __endptr, 0);
>}
>
>
>
>
>
>__extension__ extern __inline long long int
>strtoq (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()
>
>{
> return __strtoll_internal (__nptr, __endptr, __base, 0);
>}
>__extension__ extern __inline unsigned long long int
>strtouq (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()
>
>{
> return __strtoull_internal (__nptr, __endptr, __base, 0);
>}
>
>
>
>
>__extension__ extern __inline long long int
>strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()
>
>{
> return __strtoll_internal (__nptr, __endptr, __base, 0);
>}
>__extension__ extern __inline unsigned long long int
>strtoull (__const char * __restrict __nptr, char **__restrict __endptr, int __base) throw ()
>
>{
> return __strtoull_internal (__nptr, __endptr, __base, 0);
>}
>
>
>
>
>extern __inline double
>atof (__const char *__nptr) throw ()
>{
> return strtod (__nptr, (char **) __null);
>}
>extern __inline int
>atoi (__const char *__nptr) throw ()
>{
> return (int) strtol (__nptr, (char **) __null, 10);
>}
>extern __inline long int
>atol (__const char *__nptr) throw ()
>{
> return strtol (__nptr, (char **) __null, 10);
>}
>
>
>
>
>__extension__ extern __inline long long int
>atoll (__const char *__nptr) throw ()
>{
> return strtoll (__nptr, (char **) __null, 10);
>}
>
># 429 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) throw () ;
>
>
>extern long int a64l (__const char *__s)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 29 "/usr/include/sys/types.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/types.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 32 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>
>
>
>__extension__ typedef signed long long int __int64_t;
>__extension__ typedef unsigned long long int __uint64_t;
>
>
>
>
>
>
>
>__extension__ typedef long long int __quad_t;
>__extension__ typedef unsigned long long int __u_quad_t;
># 134 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 135 "/usr/include/bits/types.h" 2 3 4
>
>
>__extension__ typedef __u_quad_t __dev_t;
>__extension__ typedef unsigned int __uid_t;
>__extension__ typedef unsigned int __gid_t;
>__extension__ typedef unsigned long int __ino_t;
>__extension__ typedef __u_quad_t __ino64_t;
>__extension__ typedef unsigned int __mode_t;
>__extension__ typedef unsigned int __nlink_t;
>__extension__ typedef long int __off_t;
>__extension__ typedef __quad_t __off64_t;
>__extension__ typedef int __pid_t;
>__extension__ typedef struct { int __val[2]; } __fsid_t;
>__extension__ typedef long int __clock_t;
>__extension__ typedef unsigned long int __rlim_t;
>__extension__ typedef __u_quad_t __rlim64_t;
>__extension__ typedef unsigned int __id_t;
>__extension__ typedef long int __time_t;
>__extension__ typedef unsigned int __useconds_t;
>__extension__ typedef long int __suseconds_t;
>
>__extension__ typedef int __daddr_t;
>__extension__ typedef long int __swblk_t;
>__extension__ typedef int __key_t;
>
>
>__extension__ typedef int __clockid_t;
>
>
>__extension__ typedef void * __timer_t;
>
>
>__extension__ typedef long int __blksize_t;
>
>
>
>
>__extension__ typedef long int __blkcnt_t;
>__extension__ typedef __quad_t __blkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsblkcnt_t;
>__extension__ typedef __u_quad_t __fsblkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsfilcnt_t;
>__extension__ typedef __u_quad_t __fsfilcnt64_t;
>
>__extension__ typedef int __ssize_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>__extension__ typedef int __intptr_t;
>
>
>__extension__ typedef unsigned int __socklen_t;
># 32 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>typedef __ino_t ino_t;
>
>
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>typedef __off_t off_t;
>
>
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>typedef __id_t id_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 133 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 59 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 75 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 93 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 105 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 134 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 148 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 195 "/usr/include/sys/types.h" 3 4
>typedef int int8_t __attribute__ ((__mode__ (__QI__)));
>typedef int int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int int32_t __attribute__ ((__mode__ (__SI__)));
>typedef int int64_t __attribute__ ((__mode__ (__DI__)));
>
>
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 220 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 32 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 23 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
> {
> unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
> } __sigset_t;
># 35 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 121 "/usr/include/time.h" 3 4
>struct timespec
> {
> __time_t tv_sec;
> long int tv_nsec;
> };
># 45 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 69 "/usr/include/bits/time.h" 3 4
>struct timeval
> {
> __time_t tv_sec;
> __suseconds_t tv_usec;
> };
># 47 "/usr/include/sys/select.h" 2 3 4
># 55 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 67 "/usr/include/sys/select.h" 3 4
>typedef struct
> {
>
>
>
> __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];
>
>
>
>
>
> } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 99 "/usr/include/sys/select.h" 3 4
>extern "C" {
># 109 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
> fd_set *__restrict __writefds,
> fd_set *__restrict __exceptfds,
> struct timeval *__restrict __timeout);
># 121 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
> fd_set *__restrict __writefds,
> fd_set *__restrict __exceptfds,
> const struct timespec *__restrict __timeout,
> const __sigset_t *__restrict __sigmask);
>
>
>}
># 221 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 29 "/usr/include/sys/sysmacros.h" 3 4
>__extension__
>extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
> throw ();
>__extension__
>extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
> throw ();
>__extension__
>extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
> unsigned int __minor)
> throw ();
>
>
>__extension__ extern __inline unsigned int
>gnu_dev_major (unsigned long long int __dev) throw ()
>{
> return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline unsigned int
>gnu_dev_minor (unsigned long long int __dev) throw ()
>{
> return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline unsigned long long int
>gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
>{
> return ((__minor & 0xff) | ((__major & 0xfff) << 8)
> | (((unsigned long long int) (__minor & ~0xff)) << 12)
> | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
># 224 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>typedef __blksize_t blksize_t;
>
>
>
>
>
>
>typedef __blkcnt_t blkcnt_t;
>
>
>
>typedef __fsblkcnt_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt_t fsfilcnt_t;
># 262 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 36 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>typedef union
>{
> char __size[36];
> long int __align;
>} pthread_attr_t;
>
>
>typedef struct __pthread_internal_slist
>{
> struct __pthread_internal_slist *__next;
>} __pthread_slist_t;
>
>
>
>
>typedef union
>{
> struct __pthread_mutex_s
> {
> int __lock;
> unsigned int __count;
> int __owner;
>
>
> int __kind;
> unsigned int __nusers;
> __extension__ union
> {
> int __spins;
> __pthread_slist_t __list;
> };
> } __data;
> char __size[24];
> long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
> char __size[4];
> long int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
> struct
> {
> int __lock;
> unsigned int __futex;
> __extension__ unsigned long long int __total_seq;
> __extension__ unsigned long long int __wakeup_seq;
> __extension__ unsigned long long int __woken_seq;
> void *__mutex;
> unsigned int __nwaiters;
> unsigned int __broadcast_seq;
> } __data;
> char __size[48];
> __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
> char __size[4];
> long int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
> struct
> {
> int __lock;
> unsigned int __nr_readers;
> unsigned int __readers_wakeup;
> unsigned int __writer_wakeup;
> unsigned int __nr_readers_queued;
> unsigned int __nr_writers_queued;
>
>
> unsigned int __flags;
> int __writer;
> } __data;
> char __size[32];
> long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
> char __size[8];
> long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
> char __size[20];
> long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>}
># 439 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) throw ();
>
>
>extern void srandom (unsigned int __seed) throw ();
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
> size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
> {
> int32_t *fptr;
> int32_t *rptr;
> int32_t *state;
> int rand_type;
> int rand_deg;
> int rand_sep;
> int32_t *end_ptr;
> };
>
>extern int random_r (struct random_data *__restrict __buf,
> int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
> throw () __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
> size_t __statelen,
> struct random_data *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
> struct random_data *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) throw ();
>
>extern void srand (unsigned int __seed) throw ();
>
>
>
>
>extern int rand_r (unsigned int *__seed) throw ();
>
>
>
>
>
>
>
>extern double drand48 (void) throw ();
>extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) throw ();
>extern long int nrand48 (unsigned short int __xsubi[3])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) throw ();
>extern long int jrand48 (unsigned short int __xsubi[3])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) throw ();
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
> throw () __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
> {
> unsigned short int __x[3];
> unsigned short int __old_x[3];
> unsigned short int __c;
> unsigned short int __init;
> unsigned long long int __a;
> };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
> double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
> throw () __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
> struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
> struct drand48_data *__buffer)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
>
>extern void *calloc (size_t __nmemb, size_t __size)
> throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) throw ();
>
>
>
>
>extern void cfree (void *__ptr) throw ();
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 25 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 26 "/usr/include/alloca.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>extern void *alloca (size_t __size) throw ();
>
>
>
>
>
>}
># 613 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern void abort (void) throw () __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern char *__secure_getenv (__const char *__name)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (__const char *__name, __const char *__value, int __replace)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (__const char *__name) throw ();
>
>
>
>
>
>
>extern int clearenv (void) throw ();
># 698 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
># 709 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 719 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 729 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>extern int system (__const char *__command) ;
>
>
>
>
>
>
>
>extern char *canonicalize_file_name (__const char *__name)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 757 "/usr/include/stdlib.h" 3 4
>extern char *realpath (__const char *__restrict __name,
> char *__restrict __resolved) throw () ;
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (__const void *, __const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>
>
>
>extern void *bsearch (__const void *__key, __const void *__base,
> size_t __nmemb, size_t __size, __compar_fn_t __compar)
> __attribute__ ((__nonnull__ (1, 2, 5))) ;
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
> __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>extern int abs (int __x) throw () __attribute__ ((__const__)) ;
>extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
>
>
>
>__extension__ extern long long int llabs (long long int __x)
> throw () __attribute__ ((__const__)) ;
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
> throw () __attribute__ ((__const__)) ;
>extern ldiv_t ldiv (long int __numer, long int __denom)
> throw () __attribute__ ((__const__)) ;
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
> long long int __denom)
> throw () __attribute__ ((__const__)) ;
>
># 822 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
> throw () __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign)
> throw () __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qfcvt (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign)
> throw () __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
> throw () __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>
>extern int mblen (__const char *__s, size_t __n) throw () ;
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
> __const char *__restrict __s, size_t __n) throw () ;
>
>
>extern int wctomb (char *__s, wchar_t __wchar) throw () ;
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
> __const char *__restrict __s, size_t __n) throw ();
>
>extern size_t wcstombs (char *__restrict __s,
> __const wchar_t *__restrict __pwcs, size_t __n)
> throw ();
>
>
>
>
>
>
>
>
>extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
># 910 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
> char *__const *__restrict __tokens,
> char **__restrict __valuep)
> throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
>
>
>
>
>
>extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) ;
>
>
>
>
>
>
>
>extern int grantpt (int __fd) throw ();
>
>
>
>extern int unlockpt (int __fd) throw ();
>
>
>
>
>extern char *ptsname (int __fd) throw () ;
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
> throw () __attribute__ ((__nonnull__ (1)));
># 978 "/usr/include/stdlib.h" 3 4
>}
># 177 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 2
>
>
>typedef unsigned long err_t;
>
>
>const size_t FMRtyShortSize = 16;
>
>typedef char FMRtyShortString[16];
>
>
>const size_t FMRtyLongSize = 64;
>
>typedef char FMRtyLongString[64];
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrVisitor.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> class Instrument;
>
> namespace InstrSpecs {
>
> class Visitor
> {
> public:
> inline err_t accept(const Instrument* instrument);
> virtual ~Visitor();
>
> private:
>
> virtual err_t connect(const Instrument* instrument);
>
> virtual err_t disconnect(const Instrument* instrument);
>
> virtual err_t calculate(const Instrument* instrument) = 0;
> };
>
> }
>
> }
>
>}
>
>
>inline err_t FMR4000::Finance::InstrSpecs::Visitor::accept(const Instrument* instrument)
>{
>
>
>
>
>
> try
> {
>
> err_t err = connect(instrument);
>
> if (!err) err = calculate(instrument);
> if (err) {disconnect(instrument);}
> else {err = disconnect(instrument);}
> return err;
> }
> catch(...)
> {
> disconnect(instrument);
> return 0x09ea;
> }
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/option/fmrBasketPricer.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtAlgo.h" 1
># 52 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtAlgo.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrBaseObject.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrProduct.h" 1
># 22 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrProduct.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrBrowser.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrLock.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrLock.h" 2
>
>namespace FMR {
>
> namespace Platform {
>
> namespace Access {
>
> class Generic
> {
> public:
> Generic(void) {}
> virtual ~Generic() {}
>
> enum {code=0};
>
> template <typename Interface>
> class Types
> {
> public:
> Types(void) {}
> virtual ~Types() {}
>
> typedef Interface* Pointer;
> typedef Interface& Reference;
> };
> };
>
>
> class ReadOnly
> {
> public:
> ReadOnly(void) {}
> virtual ~ReadOnly() {}
>
> enum {code=1};
>
> template <typename Interface>
> class Types
> {
> public:
> Types(void) {}
> virtual ~Types() {}
>
> typedef const Interface* Pointer;
> typedef const Interface& Reference;
> };
> };
>
>
> class ReadWrite
> {
> public:
> ReadWrite(void) {}
> virtual ~ReadWrite() {}
>
> enum {code=2};
>
> template <typename Interface>
> class Types
> {
> public:
> Types(void) {}
> virtual ~Types() {}
>
> typedef Interface* Pointer;
> typedef Interface& Reference;
> };
> };
>
> }
>
>
> template
> <
> typename LockModel,
> typename AccessType = Access::Generic
> >
> class Lock
> {
> public:
>
>
>
> Lock(LockModel& model);
>
> Lock(Lock& that) {copy(that);}
>
> Lock& operator=(Lock& that) {if (&that!=this) {blank(); copy(that);} return *this;}
>
> virtual ~Lock() {blank();}
>
>
>
>
>
> bool is_active(void) const volatile {return status;}
>
>
> protected:
>
>
>
> Lock(void) : locker(__null), status(false) {}
>
> Lock(LockModel* model);
>
> void blank(void);
>
> void copy(Lock& that);
>
>
> private:
> LockModel* locker;
> bool status;
>
> bool (LockModel::*acquire)();
> bool (LockModel::*release)();
>
> void init(const Access::Generic&);
> void init(const Access::ReadOnly&);
> void init(const Access::ReadWrite&);
> };
>
> }
>
>}
>
>
>template <typename LM,typename AT>
>inline FMR::Platform::Lock<LM,AT>::Lock(LM& model)
> : locker(&model)
>{
> init(AT());
> status = (locker->*acquire)();
>}
>
>
>template <typename LM,typename AT>
>inline FMR::Platform::Lock<LM,AT>::Lock(LM* model)
> : locker(model)
>{
>
>
> if (!locker) {status = false; return;}
> init(AT());
> status = (locker->*acquire)();
>}
>
>
>template <typename LM,typename AT>
>inline void FMR::Platform::Lock<LM,AT>::blank(void)
>{
> if (status) (locker->*release)();
> locker = __null;
>}
>
>
>template <typename LM,typename AT>
>inline void FMR::Platform::Lock<LM,AT>::copy(Lock& that)
>{
> locker = that.locker;
> that.locker = __null;
>
> status = that.status;
> that.status = 0;
>
> release = that.release;
> acquire = that.acquire;
>}
>
>
>template <typename LM,typename AT>
>inline void FMR::Platform::Lock<LM,AT>::init(const Access::Generic&)
>{
> acquire = &LM::lock;
> release = &LM::unlock;
>}
>
>
>template <typename LM,typename AT>
>inline void FMR::Platform::Lock<LM,AT>::init(const Access::ReadOnly&)
>{
> acquire = &LM::lock_ro;
> release = &LM::unlock_ro;
>}
>
>
>template <typename LM,typename AT>
>inline void FMR::Platform::Lock<LM,AT>::init(const Access::ReadWrite&)
>{
> acquire = &LM::lock_rw;
> release = &LM::unlock_rw;
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrLockModel.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrThread.h" 1
># 31 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrThread.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrSingleThread.h" 1
># 33 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrSingleThread.h"
>namespace FMR {
>
> namespace OS {
>
> class DummyUtils
> {
> public:
> DummyUtils(void) {}
> virtual ~DummyUtils() {}
>
> static void thread_delay(unsigned long msec) {return;}
> };
>
>
> class DummyAtomicCounter
> {
> public:
>
>
>
> DummyAtomicCounter(void) : counter(0) {}
>
> virtual ~DummyAtomicCounter() {}
>
>
>
>
>
> void operator++() {++counter;}
>
> void operator--() {--counter;}
>
> bool operator!() {return 0==counter;}
>
> operator unsigned long () {return counter;}
>
>
> private:
> unsigned long counter;
> };
>
>
> class DummyMutex
> {
> public:
>
>
>
> DummyMutex(void) {}
>
> virtual ~DummyMutex() {}
>
>
>
>
>
> void EnterMutex(void) {}
>
> bool TryEnterMutex(void) {return true;}
>
> void LeaveMutex(void) {}
>
> };
>
> typedef DummyUtils DefaultUtils;
> typedef DummyAtomicCounter DefaultAtomicCounter;
> typedef DummyMutex DefaultMutex;
> typedef void DefaultThread;
> typedef void DefaultInetAddress;
> typedef void DefaultInetHostAddress;
> typedef void DefaultTCPSocket;
> typedef void DefaultTCPSession;
>
> }
>
>}
># 32 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrThread.h" 2
>
>
>namespace FMR {
>
> namespace Platform {
>
> template
> <
> typename AtomicCounter
> >
> class Semaphore
> {
> public:
>
>
>
> Semaphore(void) {}
>
> Semaphore(Semaphore& that) {copy(that);}
>
> Semaphore& operator=(Semaphore& that) {if (&that!=this) copy(that); return *this;}
>
> virtual ~Semaphore() {}
>
>
>
>
>
> void operator++(void) {++ac;}
>
> void operator--(void) {--ac;}
>
> void fmr_wait(void) {while(!!ac);}
>
> bool operator!(void) {return !ac;}
>
> operator bool() {return !!ac;}
>
> operator unsigned long() {return (unsigned long)ac;}
>
>
> private:
> void copy(Semaphore& that) {ac = that.ac;}
> AtomicCounter ac;
> };
>
>
> template
> <
> typename Mutex
> >
> class CriticalSection
> {
> public:
>
>
>
> CriticalSection(void) {}
>
> CriticalSection(CriticalSection& that) {copy(that);}
>
> CriticalSection& operator=(CriticalSection& that) {if (&that!=this) {copy(that);} return *this;}
>
> virtual ~CriticalSection() {}
>
>
>
>
>
> void enter(void) {mx.EnterMutex();}
>
> bool try_enter(void) {return mx.TryEnterMutex();}
>
> void leave(void) {mx.LeaveMutex();}
>
>
> private:
> void copy(CriticalSection& that) {mx = that.mx;}
> Mutex mx;
> };
>
>
> template
> <
> typename AtomicCounter,
> typename Mutex,
> typename _Thread,
> typename Utilities
> >
> class ThreadTrait : public Utilities
> {
> public:
> ThreadTrait(void) {}
> virtual ~ThreadTrait() {}
>
>
>
>
> typedef Semaphore<AtomicCounter> Semaphore;
>
> typedef CriticalSection<Mutex> CriticalSection;
>
> typedef _Thread Thread;
>
> };
>
>
> typedef ThreadTrait<OS::DefaultAtomicCounter,OS::DefaultMutex,OS::DefaultThread,OS::DefaultUtils> DefaultThreadTrait;
>
> }
>
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrLockModel.h" 2
>
>
>
>namespace FMR {
>
> namespace Platform {
>
> namespace Signals {
>
> struct Hup {enum {code=1};};
> struct Kill {enum {code=9};};
>
> }
>
>
> template
> <
> size_t msec = 100,
> typename ThreadModel = DefaultThreadTrait
> >
> class PollReading
> {
> public:
> PollReading(void) {}
> virtual ~PollReading() {}
>
> bool OnWriting(void)
> {
> ThreadModel::thread_delay(msec);
> return true;
> }
> };
>
> class FalseOnReading
> {
> public:
> FalseOnReading(void) {}
> virtual ~FalseOnReading() {}
>
> bool OnWriting(void) {return false;}
> };
>
>
> template
> <
> typename ThreadModel = DefaultThreadTrait
> >
> class ReferenceCounter
> {
> public:
>
>
>
>
> ReferenceCounter(void) {}
>
> virtual ~ReferenceCounter() {}
>
>
>
>
>
> bool is_referenced(void) {return counter;}
>
> unsigned long reference_number(void) {return counter;}
>
> void wait_no_reference(unsigned short msecs=100);
>
>
>
>
>
> bool increment(void) {++counter; return true;}
>
> bool decrement(void) {if (!counter) return false; --counter; return true;}
>
>
> private:
> typename ThreadModel::Semaphore counter;
> };
>
>
> template
> <
> typename ThreadModel = DefaultThreadTrait
> >
> class Barrier
> {
> public:
>
>
>
> Barrier(void) {}
>
> virtual ~Barrier() {}
>
>
>
>
>
> bool is_active(void) {return barrier;}
>
>
>
>
>
> bool shield(void) {if (barrier) return false; ++barrier; return true;}
>
> bool unshield(void) {if (!barrier) return false; --barrier; return true;}
>
>
> private:
> typename ThreadModel::Semaphore barrier;
> };
>
>
> template
> <
> typename ThreadModel = DefaultThreadTrait
> >
> class OnOffLocker
> {
> public:
>
>
>
>
> OnOffLocker(void) {}
>
> virtual ~OnOffLocker() {}
>
>
>
>
>
> bool lock(void);
>
> bool unlock(void);
>
>
>
>
>
> void signal(const Signals::Kill&);
>
>
> private:
> typename ThreadModel::CriticalSection write_lock;
> typename ThreadModel::Semaphore destroyers;
> };
>
>
> template
> <
> typename ThreadModel = DefaultThreadTrait
> >
> class CreationLocker
> {
> public:
>
>
>
> CreationLocker(void) {}
>
> virtual ~CreationLocker() {}
>
>
>
>
>
> bool try_lock(void);
>
> bool unlock(void);
>
>
>
>
> void signal(const Signals::Kill&);
>
>
> private:
> typename ThreadModel::CriticalSection create_lock;
> typename ThreadModel::Semaphore created;
> typename ThreadModel::Semaphore destroyers;
> };
>
>
> template
> <
> typename ReadPolicy = PollReading<100,DefaultThreadTrait>,
> typename ThreadModel = DefaultThreadTrait
> >
> class TwoLevelLocker : private ReadPolicy
> {
> public:
>
>
>
> TwoLevelLocker(void) {}
>
> virtual ~TwoLevelLocker() {}
>
>
>
>
>
> bool is_read(void) {return readers;}
>
> bool is_written(void) {return writers;}
>
> unsigned long reader_number(void) {return readers;}
>
> unsigned long writer_number(void) {return writers;}
>
>
>
>
>
> bool lock_ro(void);
>
> bool unlock_ro(void);
>
> bool lock_rw(void);
>
> bool unlock_rw(void);
>
>
> protected:
>
>
>
> void fmr_wait(void) {readers.fmr_wait(); writers.fmr_wait();}
>
>
> private:
> typename ThreadModel::Semaphore readers;
> typename ThreadModel::Semaphore writers;
> typename ThreadModel::CriticalSection write_lock;
> };
>
>
> template
> <
> typename ReadPolicy = PollReading<100,DefaultThreadTrait>,
> typename ThreadModel = DefaultThreadTrait
> >
> class ThreeLevelLocker : public TwoLevelLocker<ReadPolicy,ThreadModel>
> {
> public:
>
>
>
> ThreeLevelLocker(void) {}
>
> virtual ~ThreeLevelLocker() {}
>
>
>
>
>
> bool is_invalid(void) {return destroyers;}
>
>
>
>
>
> bool lock_ro(void);
>
> bool lock_rw(void);
>
>
>
>
>
> void signal(const Signals::Hup&);
>
> void signal(const Signals::Kill&);
>
>
> private:
> typename ThreadModel::Semaphore destroyers;
> };
>
> }
>
>}
>
>
>template <typename TM>
>inline void FMR::Platform::ReferenceCounter<TM>::wait_no_reference(unsigned short msecs)
>{
> while (counter)
> TM::thread_delay(msecs);
>}
>
>
>template <typename TM>
>inline bool FMR::Platform::OnOffLocker<TM>::lock(void)
>{
> if (destroyers) return false;
> write_lock.enter();
> return true;
>}
>
>
>template <typename TM>
>inline bool FMR::Platform::OnOffLocker<TM>::unlock(void)
>{
> write_lock.leave();
> return true;
>}
>
>
>template <typename TM>
>inline void FMR::Platform::OnOffLocker<TM>::signal(const Signals::Kill&)
>{
> ++destroyers;
> write_lock.enter();
>}
>
>
>template <typename TM>
>inline bool FMR::Platform::CreationLocker<TM>::try_lock(void)
>{
> if (destroyers) return false;
> if (created) return false;
> create_lock.enter();
> if (created)
> {
> create_lock.leave();
> return false;
> }
> ++created;
> return true;
>}
>
>
>template <typename TM>
>inline bool FMR::Platform::CreationLocker<TM>::unlock(void)
>{
> if (!created) return false;
> --created;
> create_lock.leave();
> return true;
>}
>
>
>template <typename TM>
>inline void FMR::Platform::CreationLocker<TM>::signal(const Signals::Kill&)
>{
> ++destroyers;
> create_lock.enter();
>}
>
>
>template <typename RP,typename TM>
>inline bool FMR::Platform::TwoLevelLocker<RP,TM>::lock_ro(void)
>{
> while (writers)
> if (!RP::OnWriting()) return false;
> ++readers;
> return true;
>}
>
>
>template <typename RP,typename TM>
>inline bool FMR::Platform::TwoLevelLocker<RP,TM>::unlock_ro(void)
>{
> if (!readers) return false;
> --readers;
> return true;
>}
>
>
>template <typename RP,typename TM>
>inline bool FMR::Platform::TwoLevelLocker<RP,TM>::lock_rw(void)
>{
> write_lock.enter();
> ++writers;
> readers.fmr_wait();
> return true;
>}
>
>
>template <typename RP,typename TM>
>inline bool FMR::Platform::TwoLevelLocker<RP,TM>::unlock_rw(void)
>{
> if (!writers) return false;
> --writers;
> write_lock.leave();
> return true;
>}
>
>
>template <typename RP,typename TM>
>inline bool FMR::Platform::ThreeLevelLocker<RP,TM>::lock_ro(void)
>{
> if (destroyers) return false;
> return TwoLevelLocker<RP,TM>::lock_ro();
>}
>
>
>template <typename RP,typename TM>
>inline bool FMR::Platform::ThreeLevelLocker<RP,TM>::lock_rw(void)
>{
> if (destroyers) return false;
> return TwoLevelLocker<RP,TM>::lock_rw();
>}
>
>
>template <typename RP,typename TM>
>inline void FMR::Platform::ThreeLevelLocker<RP,TM>::signal(const Signals::Hup&)
>{
> ++destroyers;
> this->fmr_wait();
> --destroyers;
>}
>
>
>template <typename RP,typename TM>
>inline void FMR::Platform::ThreeLevelLocker<RP,TM>::signal(const Signals::Kill&)
>{
> ++destroyers;
> this->fmr_wait();
>}
># 8 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++config.h" 1 3
># 35 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++config.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/os_defines.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++config.h" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/cpu_defines.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++config.h" 2 3
>
>
>
>
>namespace __gnu_debug_def { }
>
>namespace __gnu_debug
>{
> using namespace __gnu_debug_def;
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stringfwd.h" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stringfwd.h" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stringfwd.h" 3
>
>
>
>namespace std
>{
> template<typename _Alloc>
> class allocator;
>
> template<class _CharT>
> struct char_traits;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_string;
>
> template<> struct char_traits<char>;
>
> typedef basic_string<char> string;
>
>
> template<> struct char_traits<wchar_t>;
>
> typedef basic_string<wchar_t> wstring;
>
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstring" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstring" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstring" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstddef" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstddef" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstddef" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 152 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstddef" 2 3
>
>namespace std
>{
> using ::ptrdiff_t;
> using ::size_t;
>}
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstring" 2 3
>
># 1 "/usr/include/string.h" 1 3 4
># 28 "/usr/include/string.h" 3 4
>extern "C" {
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 34 "/usr/include/string.h" 2 3 4
>
>
>
>
>extern void *memcpy (void *__restrict __dest,
> __const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, __const void *__src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
> int __c, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memchr (__const void *__s, int __c, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern void *rawmemchr (__const void *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memrchr (__const void *__s, int __c, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
> __const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
> size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (__const char *__s1, __const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (__const char *__s1, __const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
> __const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (2)));
>
># 121 "/usr/include/string.h" 3 4
>extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
> __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>extern char *strdup (__const char *__s)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (__const char *__string, size_t __n)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 165 "/usr/include/string.h" 3 4
>
>
>extern char *strchr (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>extern char *strrchr (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strchrnul (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strcspn (__const char *__s, __const char *__reject)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (__const char *__s, __const char *__accept)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strpbrk (__const char *__s, __const char *__accept)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strstr (__const char *__haystack, __const char *__needle)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
> __const char *__restrict __delim,
> char **__restrict __save_ptr)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
> char **__restrict __save_ptr)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>extern char *strcasestr (__const char *__haystack, __const char *__needle)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memmem (__const void *__haystack, size_t __haystacklen,
> __const void *__needle, size_t __needlelen)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
> __const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
> __const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (__const char *__s)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (__const char *__string, size_t __maxlen)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) throw ();
>
># 281 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (__const void *__src, void *__dest, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *index (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern char *rindex (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int ffs (int __i) throw () __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) throw () __attribute__ ((__const__));
>
>__extension__ extern int ffsll (long long int __ll)
> throw () __attribute__ ((__const__));
>
>
>
>
>extern int strcasecmp (__const char *__s1, __const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (__const char *__s1, __const char *__s2,
> __locale_t __loc)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (__const char *__s1, __const char *__s2,
> size_t __n, __locale_t __loc)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
> __const char *__restrict __delim)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (__const char *__s1, __const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strsignal (int __sig) throw ();
>
>
>extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
> __const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
> __const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
># 426 "/usr/include/string.h" 3 4
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstring" 2 3
># 78 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstring" 3
>namespace std
>{
> using ::memcpy;
> using ::memmove;
> using ::strcpy;
> using ::strncpy;
> using ::strcat;
> using ::strncat;
> using ::memcmp;
> using ::strcmp;
> using ::strcoll;
> using ::strncmp;
> using ::strxfrm;
> using ::strcspn;
> using ::strspn;
> using ::strtok;
> using ::memset;
> using ::strerror;
> using ::strlen;
>
> using ::memchr;
>
> inline void*
> memchr(void* __p, int __c, size_t __n)
> { return memchr(const_cast<const void*>(__p), __c, __n); }
>
> using ::strchr;
>
> inline char*
> strchr(char* __s1, int __n)
> { return __builtin_strchr(const_cast<const char*>(__s1), __n); }
>
> using ::strpbrk;
>
> inline char*
> strpbrk(char* __s1, const char* __s2)
> { return __builtin_strpbrk(const_cast<const char*>(__s1), __s2); }
>
> using ::strrchr;
>
> inline char*
> strrchr(char* __s1, int __n)
> { return __builtin_strrchr(const_cast<const char*>(__s1), __n); }
>
> using ::strstr;
>
> inline char*
> strstr(char* __s1, const char* __s2)
> { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/climits" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/climits" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/climits" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/limits.h" 1 3 4
># 11 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/limits.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/limits.h" 1 3 4
># 122 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 145 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 153 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 36 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 37 "/usr/include/bits/local_lim.h" 2 3 4
># 154 "/usr/include/bits/posix1_lim.h" 2 3 4
># 146 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 150 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 35 "/usr/include/bits/xopen_lim.h" 2 3 4
># 154 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/syslimits.h" 2 3 4
># 12 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/limits.h" 2 3 4
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/climits" 2 3
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdlib" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdlib" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdlib" 3
># 103 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdlib" 3
>namespace std
>{
> using ::div_t;
> using ::ldiv_t;
>
> using ::abort;
> using ::abs;
> using ::atexit;
> using ::atof;
> using ::atoi;
> using ::atol;
> using ::bsearch;
> using ::calloc;
> using ::div;
> using ::exit;
> using ::free;
> using ::getenv;
> using ::labs;
> using ::ldiv;
> using ::malloc;
>
> using ::mblen;
> using ::mbstowcs;
> using ::mbtowc;
>
> using ::qsort;
> using ::rand;
> using ::realloc;
> using ::srand;
> using ::strtod;
> using ::strtol;
> using ::strtoul;
> using ::system;
>
> using ::wcstombs;
> using ::wctomb;
>
>
> inline long
> abs(long __i) { return labs(__i); }
>
> inline ldiv_t
> div(long __i, long __j) { return ldiv(__i, __j); }
>}
># 159 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdlib" 3
>namespace __gnu_cxx
>{
>
> using ::lldiv_t;
>
>
>
>
>
> using ::_Exit;
>
>
> inline long long
> abs(long long __x) { return __x >= 0 ? __x : -__x; }
>
>
> using ::llabs;
>
> inline lldiv_t
> div(long long __n, long long __d)
> { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
>
> using ::lldiv;
># 192 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdlib" 3
> using ::atoll;
> using ::strtoll;
> using ::strtoull;
>
> using ::strtof;
> using ::strtold;
>}
>
>namespace std
>{
>
> using ::__gnu_cxx::lldiv_t;
>
> using ::__gnu_cxx::_Exit;
> using ::__gnu_cxx::abs;
>
> using ::__gnu_cxx::llabs;
> using ::__gnu_cxx::div;
> using ::__gnu_cxx::lldiv;
>
> using ::__gnu_cxx::atoll;
> using ::__gnu_cxx::strtof;
> using ::__gnu_cxx::strtoll;
> using ::__gnu_cxx::strtoull;
> using ::__gnu_cxx::strtold;
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 3
>
>
>
>
># 1 "/usr/include/stdio.h" 1 3 4
># 30 "/usr/include/stdio.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 35 "/usr/include/stdio.h" 2 3 4
># 44 "/usr/include/stdio.h" 3 4
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 62 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 72 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 32 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 14 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 355 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 15 "/usr/include/_G_config.h" 2 3 4
># 24 "/usr/include/_G_config.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 48 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
>
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 51 "/usr/include/wchar.h" 2 3 4
># 76 "/usr/include/wchar.h" 3 4
>typedef struct
>{
> int __count;
> union
> {
> wint_t __wch;
> char __wchb[4];
> } __value;
>} __mbstate_t;
># 25 "/usr/include/_G_config.h" 2 3 4
>
>typedef struct
>{
> __off_t __pos;
> __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
> __off64_t __pos;
> __mbstate_t __state;
>} _G_fpos64_t;
># 44 "/usr/include/_G_config.h" 3 4
># 1 "/usr/include/gconv.h" 1 3 4
># 28 "/usr/include/gconv.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 48 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
># 29 "/usr/include/gconv.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 32 "/usr/include/gconv.h" 2 3 4
>
>
>
>
>
>enum
>{
> __GCONV_OK = 0,
> __GCONV_NOCONV,
> __GCONV_NODB,
> __GCONV_NOMEM,
>
> __GCONV_EMPTY_INPUT,
> __GCONV_FULL_OUTPUT,
> __GCONV_ILLEGAL_INPUT,
> __GCONV_INCOMPLETE_INPUT,
>
> __GCONV_ILLEGAL_DESCRIPTOR,
> __GCONV_INTERNAL_ERROR
>};
>
>
>
>enum
>{
> __GCONV_IS_LAST = 0x0001,
> __GCONV_IGNORE_ERRORS = 0x0002
>};
>
>
>
>struct __gconv_step;
>struct __gconv_step_data;
>struct __gconv_loaded_object;
>struct __gconv_trans_data;
>
>
>
>typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
> __const unsigned char **, __const unsigned char *,
> unsigned char **, size_t *, int, int);
>
>
>typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);
>
>
>typedef int (*__gconv_init_fct) (struct __gconv_step *);
>typedef void (*__gconv_end_fct) (struct __gconv_step *);
>
>
>
>typedef int (*__gconv_trans_fct) (struct __gconv_step *,
> struct __gconv_step_data *, void *,
> __const unsigned char *,
> __const unsigned char **,
> __const unsigned char *, unsigned char **,
> size_t *);
>
>
>typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
> __const unsigned char *,
> unsigned char *, unsigned char *);
>
>
>typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
> size_t *);
>
>
>typedef int (*__gconv_trans_init_fct) (void **, const char *);
>typedef void (*__gconv_trans_end_fct) (void *);
>
>struct __gconv_trans_data
>{
>
> __gconv_trans_fct __trans_fct;
> __gconv_trans_context_fct __trans_context_fct;
> __gconv_trans_end_fct __trans_end_fct;
> void *__data;
> struct __gconv_trans_data *__next;
>};
>
>
>
>struct __gconv_step
>{
> struct __gconv_loaded_object *__shlib_handle;
> __const char *__modname;
>
> int __counter;
>
> char *__from_name;
> char *__to_name;
>
> __gconv_fct __fct;
> __gconv_btowc_fct __btowc_fct;
> __gconv_init_fct __init_fct;
> __gconv_end_fct __end_fct;
>
>
>
> int __min_needed_from;
> int __max_needed_from;
> int __min_needed_to;
> int __max_needed_to;
>
>
> int __stateful;
>
> void *__data;
>};
>
>
>
>struct __gconv_step_data
>{
> unsigned char *__outbuf;
> unsigned char *__outbufend;
>
>
>
> int __flags;
>
>
>
> int __invocation_counter;
>
>
>
> int __internal_use;
>
> __mbstate_t *__statep;
> __mbstate_t __state;
>
>
>
> struct __gconv_trans_data *__trans;
>};
>
>
>
>typedef struct __gconv_info
>{
> size_t __nsteps;
> struct __gconv_step *__steps;
> __extension__ struct __gconv_step_data __data [];
>} *__gconv_t;
># 45 "/usr/include/_G_config.h" 2 3 4
>typedef union
>{
> struct __gconv_info __cd;
> struct
> {
> struct __gconv_info __cd;
> struct __gconv_step_data __data;
> } __combined;
>} _G_iconv_t;
>
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 166 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 176 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
> struct _IO_marker *_next;
> struct _IO_FILE *_sbuf;
>
>
>
> int _pos;
># 199 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
> __codecvt_ok,
> __codecvt_partial,
> __codecvt_error,
> __codecvt_noconv
>};
># 267 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
> int _flags;
>
>
>
>
> char* _IO_read_ptr;
> char* _IO_read_end;
> char* _IO_read_base;
> char* _IO_write_base;
> char* _IO_write_ptr;
> char* _IO_write_end;
> char* _IO_buf_base;
> char* _IO_buf_end;
>
> char *_IO_save_base;
> char *_IO_backup_base;
> char *_IO_save_end;
>
> struct _IO_marker *_markers;
>
> struct _IO_FILE *_chain;
>
> int _fileno;
>
>
>
> int _flags2;
>
> __off_t _old_offset;
>
>
>
> unsigned short _cur_column;
> signed char _vtable_offset;
> char _shortbuf[1];
>
>
>
> _IO_lock_t *_lock;
># 315 "/usr/include/libio.h" 3 4
> __off64_t _offset;
># 324 "/usr/include/libio.h" 3 4
> void *__pad1;
> void *__pad2;
> void *__pad3;
> void *__pad4;
> size_t __pad5;
>
> int _mode;
>
> char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 360 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
> size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
> __io_read_fn *read;
> __io_write_fn *write;
> __io_seek_fn *seek;
> __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
> void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>extern "C" {
>
>
>extern int __underflow (_IO_FILE *) throw ();
>extern int __uflow (_IO_FILE *) throw ();
>extern int __overflow (_IO_FILE *, int) throw ();
>extern wint_t __wunderflow (_IO_FILE *) throw ();
>extern wint_t __wuflow (_IO_FILE *) throw ();
>extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();
># 450 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp) throw ();
>extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
>extern int _IO_feof (_IO_FILE *__fp) throw ();
>extern int _IO_ferror (_IO_FILE *__fp) throw ();
>
>extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) throw ();
>extern void _IO_funlockfile (_IO_FILE *) throw ();
>extern int _IO_ftrylockfile (_IO_FILE *) throw ();
># 480 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
> __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
> __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();
>
>extern void _IO_free_backup_area (_IO_FILE *) throw ();
># 542 "/usr/include/libio.h" 3 4
>}
># 73 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 86 "/usr/include/stdio.h" 3 4
>
>
>typedef _G_fpos_t fpos_t;
>
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 138 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 139 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>
>
>extern int remove (__const char *__filename) throw ();
>
>extern int rename (__const char *__old, __const char *__new) throw ();
>
>
>
>
>extern int renameat (int __oldfd, __const char *__old, int __newfd,
> __const char *__new) throw ();
>
>
>
>
>
>
>
>
>extern FILE *tmpfile (void);
># 181 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void);
>
>
>
>extern char *tmpnam (char *__s) throw ();
>
>
>
>
>
>extern char *tmpnam_r (char *__s) throw ();
># 203 "/usr/include/stdio.h" 3 4
>extern char *tempnam (__const char *__dir, __const char *__pfx)
> throw () __attribute__ ((__malloc__));
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 228 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 238 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
>
>
>
>
>
>extern FILE *fopen (__const char *__restrict __filename,
> __const char *__restrict __modes);
>
>
>
>
>extern FILE *freopen (__const char *__restrict __filename,
> __const char *__restrict __modes,
> FILE *__restrict __stream);
># 269 "/usr/include/stdio.h" 3 4
>
>
>extern FILE *fopen64 (__const char *__restrict __filename,
> __const char *__restrict __modes);
>extern FILE *freopen64 (__const char *__restrict __filename,
> __const char *__restrict __modes,
> FILE *__restrict __stream);
>
>
>
>
>extern FILE *fdopen (int __fd, __const char *__modes) throw ();
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
> __const char *__restrict __modes,
> _IO_cookie_io_functions_t __io_funcs) throw ();
>
>
>extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) throw ();
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw ();
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
> int __modes, size_t __n) throw ();
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
> size_t __size) throw ();
>
>
>extern void setlinebuf (FILE *__stream) throw ();
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
> __const char *__restrict __format, ...);
>
>
>
>
>extern int printf (__const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
> __const char *__restrict __format, ...) throw ();
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
> __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
> __gnuc_va_list __arg) throw ();
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
> __const char *__restrict __format, ...)
> throw () __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
> __const char *__restrict __format, __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
> __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int __asprintf (char **__restrict __ptr,
> __const char *__restrict __fmt, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int asprintf (char **__restrict __ptr,
> __const char *__restrict __fmt, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>extern int vdprintf (int __fd, __const char *__restrict __fmt,
> __gnuc_va_list __arg)
> __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
> __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
> __const char *__restrict __format, ...) ;
>
>
>
>
>extern int scanf (__const char *__restrict __format, ...) ;
>
>extern int sscanf (__const char *__restrict __s,
> __const char *__restrict __format, ...) throw ();
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
> __gnuc_va_list __arg)
> __attribute__ ((__format__ (__scanf__, 2, 0))) ;
>
>
>
>
>
>extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
> __attribute__ ((__format__ (__scanf__, 1, 0))) ;
>
>
>extern int vsscanf (__const char *__restrict __s,
> __const char *__restrict __format, __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 460 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 471 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 504 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
> ;
>
>
>
>
>
>
>extern char *gets (char *__s) ;
>
># 550 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
> FILE *__restrict __stream) ;
># 566 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
> size_t *__restrict __n, int __delimiter,
> FILE *__restrict __stream) ;
>extern __ssize_t getdelim (char **__restrict __lineptr,
> size_t *__restrict __n, int __delimiter,
> FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
> size_t *__restrict __n,
> FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (__const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __s) ;
>
># 627 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (__const char *__restrict __s,
> FILE *__restrict __stream);
># 638 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) ;
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 674 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream) ;
># 693 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
>
>
>
>
>extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
># 716 "/usr/include/stdio.h" 3 4
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) ;
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) throw ();
>
>extern int feof (FILE *__stream) throw () ;
>
>extern int ferror (FILE *__stream) throw () ;
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) throw ();
>extern int feof_unlocked (FILE *__stream) throw () ;
>extern int ferror_unlocked (FILE *__stream) throw () ;
>
>
>
>
>
>
>
>
>extern void perror (__const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 27 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern __const char *__const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern __const char *__const _sys_errlist[];
># 755 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) throw () ;
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) throw () ;
># 774 "/usr/include/stdio.h" 3 4
>extern FILE *popen (__const char *__command, __const char *__modes) ;
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) throw ();
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
> __const char *__restrict __format, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
> __const char *__restrict __format,
> __gnuc_va_list __args)
> throw () __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) throw ();
>
>
>
>extern int ftrylockfile (FILE *__stream) throw () ;
>
>
>extern void funlockfile (FILE *__stream) throw ();
># 835 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 33 "/usr/include/bits/stdio.h" 3 4
>inline int
>vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
>{
> return vfprintf (stdout, __fmt, __arg);
>}
>
>
>inline int
>getchar (void)
>{
> return _IO_getc (stdin);
>}
>
>
>
>
>inline int
>getc_unlocked (FILE *__fp)
>{
> return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>inline int
>getchar_unlocked (void)
>{
> return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>inline int
>putchar (int __c)
>{
> return _IO_putc (__c, stdout);
>}
>
>
>
>
>inline int
>fputc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>inline int
>putc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>inline int
>putchar_unlocked (int __c)
>{
> return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>inline __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
> return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>inline int
>feof_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>inline int
>ferror_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x20) != 0);
>}
># 836 "/usr/include/stdio.h" 2 3 4
># 844 "/usr/include/stdio.h" 3 4
>}
># 54 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 2 3
># 98 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 3
>namespace std
>{
> using ::FILE;
> using ::fpos_t;
>
> using ::clearerr;
> using ::fclose;
> using ::feof;
> using ::ferror;
> using ::fflush;
> using ::fgetc;
> using ::fgetpos;
> using ::fgets;
> using ::fopen;
> using ::fprintf;
> using ::fputc;
> using ::fputs;
> using ::fread;
> using ::freopen;
> using ::fscanf;
> using ::fseek;
> using ::fsetpos;
> using ::ftell;
> using ::fwrite;
> using ::getc;
> using ::getchar;
> using ::gets;
> using ::perror;
> using ::printf;
> using ::putc;
> using ::putchar;
> using ::puts;
> using ::remove;
> using ::rename;
> using ::rewind;
> using ::scanf;
> using ::setbuf;
> using ::setvbuf;
> using ::sprintf;
> using ::sscanf;
> using ::tmpfile;
> using ::tmpnam;
> using ::ungetc;
> using ::vfprintf;
> using ::vprintf;
> using ::vsprintf;
>}
># 154 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 3
>namespace __gnu_cxx
>{
># 169 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cstdio" 3
> using ::snprintf;
> using ::vfscanf;
> using ::vscanf;
> using ::vsnprintf;
> using ::vsscanf;
>
>}
>
>namespace std
>{
> using __gnu_cxx::snprintf;
> using __gnu_cxx::vfscanf;
> using __gnu_cxx::vscanf;
> using __gnu_cxx::vsnprintf;
> using __gnu_cxx::vsscanf;
>}
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/clocale" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/clocale" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/clocale" 3
>
># 1 "/usr/include/locale.h" 1 3 4
># 29 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 27 "/usr/include/bits/locale.h" 3 4
>enum
>{
> __LC_CTYPE = 0,
> __LC_NUMERIC = 1,
> __LC_TIME = 2,
> __LC_COLLATE = 3,
> __LC_MONETARY = 4,
> __LC_MESSAGES = 5,
> __LC_ALL = 6,
> __LC_PAPER = 7,
> __LC_NAME = 8,
> __LC_ADDRESS = 9,
> __LC_TELEPHONE = 10,
> __LC_MEASUREMENT = 11,
> __LC_IDENTIFICATION = 12
>};
># 31 "/usr/include/locale.h" 2 3 4
>
>extern "C" {
># 52 "/usr/include/locale.h" 3 4
>struct lconv
>{
>
>
> char *decimal_point;
> char *thousands_sep;
>
>
>
>
>
> char *grouping;
>
>
>
>
>
> char *int_curr_symbol;
> char *currency_symbol;
> char *mon_decimal_point;
> char *mon_thousands_sep;
> char *mon_grouping;
> char *positive_sign;
> char *negative_sign;
> char int_frac_digits;
> char frac_digits;
>
> char p_cs_precedes;
>
> char p_sep_by_space;
>
> char n_cs_precedes;
>
> char n_sep_by_space;
>
>
>
>
>
>
> char p_sign_posn;
> char n_sign_posn;
>
>
> char int_p_cs_precedes;
>
> char int_p_sep_by_space;
>
> char int_n_cs_precedes;
>
> char int_n_sep_by_space;
>
>
>
>
>
>
> char int_p_sign_posn;
> char int_n_sign_posn;
># 119 "/usr/include/locale.h" 3 4
>};
>
>
>
>
>
>extern char *setlocale (int __category, __const char *__locale) throw ();
>
>
>extern struct lconv *localeconv (void) throw ();
>
>
># 148 "/usr/include/locale.h" 3 4
>typedef __locale_t locale_t;
>
>
>
>
>
>extern __locale_t newlocale (int __category_mask, __const char *__locale,
> __locale_t __base) throw ();
># 189 "/usr/include/locale.h" 3 4
>extern __locale_t duplocale (__locale_t __dataset) throw ();
>
>
>
>extern void freelocale (__locale_t __dataset) throw ();
>
>
>
>
>
>
>extern __locale_t uselocale (__locale_t __dataset) throw ();
>
>
>
>
>
>
>
>}
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/clocale" 2 3
>
>
>
>
>
>namespace std
>{
> using ::lconv;
> using ::setlocale;
> using ::localeconv;
>}
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/include/langinfo.h" 1 3 4
># 24 "/usr/include/langinfo.h" 3 4
># 1 "/usr/include/nl_types.h" 1 3 4
># 31 "/usr/include/nl_types.h" 3 4
>extern "C" {
>
>
>typedef void *nl_catd;
>
>
>typedef int nl_item;
>
>
>
>
>
>extern nl_catd catopen (__const char *__cat_name, int __flag) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern char *catgets (nl_catd __catalog, int __set, int __number,
> __const char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int catclose (nl_catd __catalog) throw () __attribute__ ((__nonnull__ (1)));
>
>}
># 25 "/usr/include/langinfo.h" 2 3 4
>
># 1 "/usr/include/bits/locale.h" 1 3 4
># 27 "/usr/include/langinfo.h" 2 3 4
>
>
>extern "C" {
># 42 "/usr/include/langinfo.h" 3 4
>enum
>{
>
>
>
> ABDAY_1 = (((__LC_TIME) << 16) | (0)),
>
> ABDAY_2,
>
> ABDAY_3,
>
> ABDAY_4,
>
> ABDAY_5,
>
> ABDAY_6,
>
> ABDAY_7,
>
>
>
> DAY_1,
>
> DAY_2,
>
> DAY_3,
>
> DAY_4,
>
> DAY_5,
>
> DAY_6,
>
> DAY_7,
>
>
>
> ABMON_1,
>
> ABMON_2,
>
> ABMON_3,
>
> ABMON_4,
>
> ABMON_5,
>
> ABMON_6,
>
> ABMON_7,
>
> ABMON_8,
>
> ABMON_9,
>
> ABMON_10,
>
> ABMON_11,
>
> ABMON_12,
>
>
>
> MON_1,
>
> MON_2,
>
> MON_3,
>
> MON_4,
>
> MON_5,
>
> MON_6,
>
> MON_7,
>
> MON_8,
>
> MON_9,
>
> MON_10,
>
> MON_11,
>
> MON_12,
>
>
> AM_STR,
>
> PM_STR,
>
>
> D_T_FMT,
>
> D_FMT,
>
> T_FMT,
>
> T_FMT_AMPM,
>
>
> ERA,
>
> __ERA_YEAR,
>
>
>
> ERA_D_FMT,
>
> ALT_DIGITS,
>
> ERA_D_T_FMT,
>
> ERA_T_FMT,
>
>
> _NL_TIME_ERA_NUM_ENTRIES,
> _NL_TIME_ERA_ENTRIES,
>
> _NL_WABDAY_1,
> _NL_WABDAY_2,
> _NL_WABDAY_3,
> _NL_WABDAY_4,
> _NL_WABDAY_5,
> _NL_WABDAY_6,
> _NL_WABDAY_7,
>
>
> _NL_WDAY_1,
> _NL_WDAY_2,
> _NL_WDAY_3,
> _NL_WDAY_4,
> _NL_WDAY_5,
> _NL_WDAY_6,
> _NL_WDAY_7,
>
>
> _NL_WABMON_1,
> _NL_WABMON_2,
> _NL_WABMON_3,
> _NL_WABMON_4,
> _NL_WABMON_5,
> _NL_WABMON_6,
> _NL_WABMON_7,
> _NL_WABMON_8,
> _NL_WABMON_9,
> _NL_WABMON_10,
> _NL_WABMON_11,
> _NL_WABMON_12,
>
>
> _NL_WMON_1,
> _NL_WMON_2,
> _NL_WMON_3,
> _NL_WMON_4,
> _NL_WMON_5,
> _NL_WMON_6,
> _NL_WMON_7,
> _NL_WMON_8,
> _NL_WMON_9,
> _NL_WMON_10,
> _NL_WMON_11,
> _NL_WMON_12,
>
> _NL_WAM_STR,
> _NL_WPM_STR,
>
> _NL_WD_T_FMT,
> _NL_WD_FMT,
> _NL_WT_FMT,
> _NL_WT_FMT_AMPM,
>
> _NL_WERA_YEAR,
> _NL_WERA_D_FMT,
> _NL_WALT_DIGITS,
> _NL_WERA_D_T_FMT,
> _NL_WERA_T_FMT,
>
> _NL_TIME_WEEK_NDAYS,
> _NL_TIME_WEEK_1STDAY,
> _NL_TIME_WEEK_1STWEEK,
> _NL_TIME_FIRST_WEEKDAY,
> _NL_TIME_FIRST_WORKDAY,
> _NL_TIME_CAL_DIRECTION,
> _NL_TIME_TIMEZONE,
>
> _DATE_FMT,
>
> _NL_W_DATE_FMT,
>
> _NL_TIME_CODESET,
>
> _NL_NUM_LC_TIME,
>
>
>
>
> _NL_COLLATE_NRULES = (((__LC_COLLATE) << 16) | (0)),
> _NL_COLLATE_RULESETS,
> _NL_COLLATE_TABLEMB,
> _NL_COLLATE_WEIGHTMB,
> _NL_COLLATE_EXTRAMB,
> _NL_COLLATE_INDIRECTMB,
> _NL_COLLATE_GAP1,
> _NL_COLLATE_GAP2,
> _NL_COLLATE_GAP3,
> _NL_COLLATE_TABLEWC,
> _NL_COLLATE_WEIGHTWC,
> _NL_COLLATE_EXTRAWC,
> _NL_COLLATE_INDIRECTWC,
> _NL_COLLATE_SYMB_HASH_SIZEMB,
> _NL_COLLATE_SYMB_TABLEMB,
> _NL_COLLATE_SYMB_EXTRAMB,
> _NL_COLLATE_COLLSEQMB,
> _NL_COLLATE_COLLSEQWC,
> _NL_COLLATE_CODESET,
> _NL_NUM_LC_COLLATE,
>
>
>
>
> _NL_CTYPE_CLASS = (((__LC_CTYPE) << 16) | (0)),
> _NL_CTYPE_TOUPPER,
> _NL_CTYPE_GAP1,
> _NL_CTYPE_TOLOWER,
> _NL_CTYPE_GAP2,
> _NL_CTYPE_CLASS32,
> _NL_CTYPE_GAP3,
> _NL_CTYPE_GAP4,
> _NL_CTYPE_GAP5,
> _NL_CTYPE_GAP6,
> _NL_CTYPE_CLASS_NAMES,
> _NL_CTYPE_MAP_NAMES,
> _NL_CTYPE_WIDTH,
> _NL_CTYPE_MB_CUR_MAX,
> _NL_CTYPE_CODESET_NAME,
> CODESET = _NL_CTYPE_CODESET_NAME,
>
> _NL_CTYPE_TOUPPER32,
> _NL_CTYPE_TOLOWER32,
> _NL_CTYPE_CLASS_OFFSET,
> _NL_CTYPE_MAP_OFFSET,
> _NL_CTYPE_INDIGITS_MB_LEN,
> _NL_CTYPE_INDIGITS0_MB,
> _NL_CTYPE_INDIGITS1_MB,
> _NL_CTYPE_INDIGITS2_MB,
> _NL_CTYPE_INDIGITS3_MB,
> _NL_CTYPE_INDIGITS4_MB,
> _NL_CTYPE_INDIGITS5_MB,
> _NL_CTYPE_INDIGITS6_MB,
> _NL_CTYPE_INDIGITS7_MB,
> _NL_CTYPE_INDIGITS8_MB,
> _NL_CTYPE_INDIGITS9_MB,
> _NL_CTYPE_INDIGITS_WC_LEN,
> _NL_CTYPE_INDIGITS0_WC,
> _NL_CTYPE_INDIGITS1_WC,
> _NL_CTYPE_INDIGITS2_WC,
> _NL_CTYPE_INDIGITS3_WC,
> _NL_CTYPE_INDIGITS4_WC,
> _NL_CTYPE_INDIGITS5_WC,
> _NL_CTYPE_INDIGITS6_WC,
> _NL_CTYPE_INDIGITS7_WC,
> _NL_CTYPE_INDIGITS8_WC,
> _NL_CTYPE_INDIGITS9_WC,
> _NL_CTYPE_OUTDIGIT0_MB,
> _NL_CTYPE_OUTDIGIT1_MB,
> _NL_CTYPE_OUTDIGIT2_MB,
> _NL_CTYPE_OUTDIGIT3_MB,
> _NL_CTYPE_OUTDIGIT4_MB,
> _NL_CTYPE_OUTDIGIT5_MB,
> _NL_CTYPE_OUTDIGIT6_MB,
> _NL_CTYPE_OUTDIGIT7_MB,
> _NL_CTYPE_OUTDIGIT8_MB,
> _NL_CTYPE_OUTDIGIT9_MB,
> _NL_CTYPE_OUTDIGIT0_WC,
> _NL_CTYPE_OUTDIGIT1_WC,
> _NL_CTYPE_OUTDIGIT2_WC,
> _NL_CTYPE_OUTDIGIT3_WC,
> _NL_CTYPE_OUTDIGIT4_WC,
> _NL_CTYPE_OUTDIGIT5_WC,
> _NL_CTYPE_OUTDIGIT6_WC,
> _NL_CTYPE_OUTDIGIT7_WC,
> _NL_CTYPE_OUTDIGIT8_WC,
> _NL_CTYPE_OUTDIGIT9_WC,
> _NL_CTYPE_TRANSLIT_TAB_SIZE,
> _NL_CTYPE_TRANSLIT_FROM_IDX,
> _NL_CTYPE_TRANSLIT_FROM_TBL,
> _NL_CTYPE_TRANSLIT_TO_IDX,
> _NL_CTYPE_TRANSLIT_TO_TBL,
> _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN,
> _NL_CTYPE_TRANSLIT_DEFAULT_MISSING,
> _NL_CTYPE_TRANSLIT_IGNORE_LEN,
> _NL_CTYPE_TRANSLIT_IGNORE,
> _NL_CTYPE_MAP_TO_NONASCII,
> _NL_CTYPE_EXTRA_MAP_1,
> _NL_CTYPE_EXTRA_MAP_2,
> _NL_CTYPE_EXTRA_MAP_3,
> _NL_CTYPE_EXTRA_MAP_4,
> _NL_CTYPE_EXTRA_MAP_5,
> _NL_CTYPE_EXTRA_MAP_6,
> _NL_CTYPE_EXTRA_MAP_7,
> _NL_CTYPE_EXTRA_MAP_8,
> _NL_CTYPE_EXTRA_MAP_9,
> _NL_CTYPE_EXTRA_MAP_10,
> _NL_CTYPE_EXTRA_MAP_11,
> _NL_CTYPE_EXTRA_MAP_12,
> _NL_CTYPE_EXTRA_MAP_13,
> _NL_CTYPE_EXTRA_MAP_14,
> _NL_NUM_LC_CTYPE,
>
>
>
>
> __INT_CURR_SYMBOL = (((__LC_MONETARY) << 16) | (0)),
>
>
>
> __CURRENCY_SYMBOL,
>
>
>
> __MON_DECIMAL_POINT,
>
>
>
> __MON_THOUSANDS_SEP,
>
>
>
> __MON_GROUPING,
>
>
>
> __POSITIVE_SIGN,
>
>
>
> __NEGATIVE_SIGN,
>
>
>
> __INT_FRAC_DIGITS,
>
>
>
> __FRAC_DIGITS,
>
>
>
> __P_CS_PRECEDES,
>
>
>
> __P_SEP_BY_SPACE,
>
>
>
> __N_CS_PRECEDES,
>
>
>
> __N_SEP_BY_SPACE,
>
>
>
> __P_SIGN_POSN,
>
>
>
> __N_SIGN_POSN,
>
>
>
> _NL_MONETARY_CRNCYSTR,
>
> __INT_P_CS_PRECEDES,
>
>
>
> __INT_P_SEP_BY_SPACE,
>
>
>
> __INT_N_CS_PRECEDES,
>
>
>
> __INT_N_SEP_BY_SPACE,
>
>
>
> __INT_P_SIGN_POSN,
>
>
>
> __INT_N_SIGN_POSN,
>
>
>
> _NL_MONETARY_DUO_INT_CURR_SYMBOL,
> _NL_MONETARY_DUO_CURRENCY_SYMBOL,
> _NL_MONETARY_DUO_INT_FRAC_DIGITS,
> _NL_MONETARY_DUO_FRAC_DIGITS,
> _NL_MONETARY_DUO_P_CS_PRECEDES,
> _NL_MONETARY_DUO_P_SEP_BY_SPACE,
> _NL_MONETARY_DUO_N_CS_PRECEDES,
> _NL_MONETARY_DUO_N_SEP_BY_SPACE,
> _NL_MONETARY_DUO_INT_P_CS_PRECEDES,
> _NL_MONETARY_DUO_INT_P_SEP_BY_SPACE,
> _NL_MONETARY_DUO_INT_N_CS_PRECEDES,
> _NL_MONETARY_DUO_INT_N_SEP_BY_SPACE,
> _NL_MONETARY_DUO_P_SIGN_POSN,
> _NL_MONETARY_DUO_N_SIGN_POSN,
> _NL_MONETARY_DUO_INT_P_SIGN_POSN,
> _NL_MONETARY_DUO_INT_N_SIGN_POSN,
> _NL_MONETARY_UNO_VALID_FROM,
> _NL_MONETARY_UNO_VALID_TO,
> _NL_MONETARY_DUO_VALID_FROM,
> _NL_MONETARY_DUO_VALID_TO,
> _NL_MONETARY_CONVERSION_RATE,
> _NL_MONETARY_DECIMAL_POINT_WC,
> _NL_MONETARY_THOUSANDS_SEP_WC,
> _NL_MONETARY_CODESET,
> _NL_NUM_LC_MONETARY,
>
>
>
> __DECIMAL_POINT = (((__LC_NUMERIC) << 16) | (0)),
>
>
>
> RADIXCHAR = __DECIMAL_POINT,
>
> __THOUSANDS_SEP,
>
>
>
> THOUSEP = __THOUSANDS_SEP,
>
> __GROUPING,
>
>
>
> _NL_NUMERIC_DECIMAL_POINT_WC,
> _NL_NUMERIC_THOUSANDS_SEP_WC,
> _NL_NUMERIC_CODESET,
> _NL_NUM_LC_NUMERIC,
>
> __YESEXPR = (((__LC_MESSAGES) << 16) | (0)),
>
> __NOEXPR,
>
> __YESSTR,
>
>
>
> __NOSTR,
>
>
>
> _NL_MESSAGES_CODESET,
> _NL_NUM_LC_MESSAGES,
>
> _NL_PAPER_HEIGHT = (((__LC_PAPER) << 16) | (0)),
> _NL_PAPER_WIDTH,
> _NL_PAPER_CODESET,
> _NL_NUM_LC_PAPER,
>
> _NL_NAME_NAME_FMT = (((__LC_NAME) << 16) | (0)),
> _NL_NAME_NAME_GEN,
> _NL_NAME_NAME_MR,
> _NL_NAME_NAME_MRS,
> _NL_NAME_NAME_MISS,
> _NL_NAME_NAME_MS,
> _NL_NAME_CODESET,
> _NL_NUM_LC_NAME,
>
> _NL_ADDRESS_POSTAL_FMT = (((__LC_ADDRESS) << 16) | (0)),
> _NL_ADDRESS_COUNTRY_NAME,
> _NL_ADDRESS_COUNTRY_POST,
> _NL_ADDRESS_COUNTRY_AB2,
> _NL_ADDRESS_COUNTRY_AB3,
> _NL_ADDRESS_COUNTRY_CAR,
> _NL_ADDRESS_COUNTRY_NUM,
> _NL_ADDRESS_COUNTRY_ISBN,
> _NL_ADDRESS_LANG_NAME,
> _NL_ADDRESS_LANG_AB,
> _NL_ADDRESS_LANG_TERM,
> _NL_ADDRESS_LANG_LIB,
> _NL_ADDRESS_CODESET,
> _NL_NUM_LC_ADDRESS,
>
> _NL_TELEPHONE_TEL_INT_FMT = (((__LC_TELEPHONE) << 16) | (0)),
> _NL_TELEPHONE_TEL_DOM_FMT,
> _NL_TELEPHONE_INT_SELECT,
> _NL_TELEPHONE_INT_PREFIX,
> _NL_TELEPHONE_CODESET,
> _NL_NUM_LC_TELEPHONE,
>
> _NL_MEASUREMENT_MEASUREMENT = (((__LC_MEASUREMENT) << 16) | (0)),
> _NL_MEASUREMENT_CODESET,
> _NL_NUM_LC_MEASUREMENT,
>
> _NL_IDENTIFICATION_TITLE = (((__LC_IDENTIFICATION) << 16) | (0)),
> _NL_IDENTIFICATION_SOURCE,
> _NL_IDENTIFICATION_ADDRESS,
> _NL_IDENTIFICATION_CONTACT,
> _NL_IDENTIFICATION_EMAIL,
> _NL_IDENTIFICATION_TEL,
> _NL_IDENTIFICATION_FAX,
> _NL_IDENTIFICATION_LANGUAGE,
> _NL_IDENTIFICATION_TERRITORY,
> _NL_IDENTIFICATION_AUDIENCE,
> _NL_IDENTIFICATION_APPLICATION,
> _NL_IDENTIFICATION_ABBREVIATION,
> _NL_IDENTIFICATION_REVISION,
> _NL_IDENTIFICATION_DATE,
> _NL_IDENTIFICATION_CATEGORY,
> _NL_IDENTIFICATION_CODESET,
> _NL_NUM_LC_IDENTIFICATION,
>
>
> _NL_NUM
>};
># 582 "/usr/include/langinfo.h" 3 4
>extern char *nl_langinfo (nl_item __item) throw ();
># 593 "/usr/include/langinfo.h" 3 4
>extern char *nl_langinfo_l (nl_item __item, __locale_t l);
>
>
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/include/iconv.h" 1 3 4
># 24 "/usr/include/iconv.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 25 "/usr/include/iconv.h" 2 3 4
>
>
>extern "C" {
>
>
>typedef void *iconv_t;
>
>
>
>
>
>
>
>extern iconv_t iconv_open (__const char *__tocode, __const char *__fromcode);
>
>
>
>
>extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
> size_t *__restrict __inbytesleft,
> char **__restrict __outbuf,
> size_t *__restrict __outbytesleft);
>
>
>
>
>
>extern int iconv_close (iconv_t __cd);
>
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/include/libintl.h" 1 3 4
># 35 "/usr/include/libintl.h" 3 4
>extern "C" {
>
>
>
>
>extern char *gettext (__const char *__msgid)
> throw () __attribute__ ((__format_arg__ (1)));
>
>
>
>extern char *dgettext (__const char *__domainname, __const char *__msgid)
> throw () __attribute__ ((__format_arg__ (2)));
>extern char *__dgettext (__const char *__domainname, __const char *__msgid)
> throw () __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dcgettext (__const char *__domainname,
> __const char *__msgid, int __category)
> throw () __attribute__ ((__format_arg__ (2)));
>extern char *__dcgettext (__const char *__domainname,
> __const char *__msgid, int __category)
> throw () __attribute__ ((__format_arg__ (2)));
>
>
>
>
>extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
> unsigned long int __n)
> throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dngettext (__const char *__domainname, __const char *__msgid1,
> __const char *__msgid2, unsigned long int __n)
> throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
> __const char *__msgid2, unsigned long int __n,
> int __category)
> throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>
>
>extern char *textdomain (__const char *__domainname) throw ();
>
>
>
>extern char *bindtextdomain (__const char *__domainname,
> __const char *__dirname) throw ();
>
>
>
>extern char *bind_textdomain_codeset (__const char *__domainname,
> __const char *__codeset) throw ();
># 122 "/usr/include/libintl.h" 3 4
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 2 3
>
>
>
>
>
>
>namespace __gnu_cxx
>{
> extern "C" __typeof(uselocale) __uselocale;
>}
>
>
>namespace std
>{
> typedef __locale_t __c_locale;
>
>
>
>
>
> template<typename _Tv>
> int
> __convert_from_v(char* __out,
> const int __size __attribute__ ((__unused__)),
> const char* __fmt,
>
> _Tv __v, const __c_locale& __cloc, int __prec)
> {
> __c_locale __old = __gnu_cxx::__uselocale(__cloc);
># 86 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++locale.h" 3
> const int __ret = std::snprintf(__out, __size, __fmt, __prec, __v);
>
>
>
>
>
> __gnu_cxx::__uselocale(__old);
>
>
>
>
> return __ret;
> }
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++io.h" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++io.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr.h" 1 3
># 33 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr.h" 3
>#pragma GCC visibility push(default)
># 114 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 3
># 1 "/usr/include/pthread.h" 1 3 4
># 23 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 29 "/usr/include/sched.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 30 "/usr/include/sched.h" 2 3 4
>
>
># 1 "/usr/include/bits/sched.h" 1 3 4
># 65 "/usr/include/bits/sched.h" 3 4
>struct sched_param
> {
> int __sched_priority;
> };
>
>extern "C" {
>
>
>
>extern int clone (int (*__fn) (void *__arg), void *__child_stack,
> int __flags, void *__arg, ...) throw ();
>
>
>extern int unshare (int __flags) throw ();
>
>
>}
>
>
>
>
>
>
>
>struct __sched_param
> {
> int __sched_priority;
> };
># 104 "/usr/include/bits/sched.h" 3 4
>typedef unsigned long int __cpu_mask;
>
>
>
>
>
>
>typedef struct
>{
> __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
>} cpu_set_t;
># 33 "/usr/include/sched.h" 2 3 4
>
>
>
>
>extern "C" {
>
>
>extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param)
> throw ();
>
>
>extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
>
>
>extern int sched_setscheduler (__pid_t __pid, int __policy,
> __const struct sched_param *__param) throw ();
>
>
>extern int sched_getscheduler (__pid_t __pid) throw ();
>
>
>extern int sched_yield (void) throw ();
>
>
>extern int sched_get_priority_max (int __algorithm) throw ();
>
>
>extern int sched_get_priority_min (int __algorithm) throw ();
>
>
>extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
># 76 "/usr/include/sched.h" 3 4
>extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
> __const cpu_set_t *__cpuset) throw ();
>
>
>extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
> cpu_set_t *__cpuset) throw ();
>
>
>}
># 24 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 31 "/usr/include/time.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 40 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 44 "/usr/include/time.h" 2 3 4
># 132 "/usr/include/time.h" 3 4
>
>
>struct tm
>{
> int tm_sec;
> int tm_min;
> int tm_hour;
> int tm_mday;
> int tm_mon;
> int tm_year;
> int tm_wday;
> int tm_yday;
> int tm_isdst;
>
>
> long int tm_gmtoff;
> __const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
> {
> struct timespec it_interval;
> struct timespec it_value;
> };
>
>
>struct sigevent;
># 181 "/usr/include/time.h" 3 4
>
>
>
>extern clock_t clock (void) throw ();
>
>
>extern time_t time (time_t *__timer) throw ();
>
>
>extern double difftime (time_t __time1, time_t __time0)
> throw () __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) throw ();
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
> __const char *__restrict __format,
> __const struct tm *__restrict __tp) throw ();
>
>
>
>
>
>extern char *strptime (__const char *__restrict __s,
> __const char *__restrict __fmt, struct tm *__tp)
> throw ();
>
>
>
>
>
>
>
>extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
> __const char *__restrict __format,
> __const struct tm *__restrict __tp,
> __locale_t __loc) throw ();
>
>extern char *strptime_l (__const char *__restrict __s,
> __const char *__restrict __fmt, struct tm *__tp,
> __locale_t __loc) throw ();
>
>
>
>
>
>
>extern struct tm *gmtime (__const time_t *__timer) throw ();
>
>
>
>extern struct tm *localtime (__const time_t *__timer) throw ();
>
>
>
>
>
>extern struct tm *gmtime_r (__const time_t *__restrict __timer,
> struct tm *__restrict __tp) throw ();
>
>
>
>extern struct tm *localtime_r (__const time_t *__restrict __timer,
> struct tm *__restrict __tp) throw ();
>
>
>
>
>
>extern char *asctime (__const struct tm *__tp) throw ();
>
>
>extern char *ctime (__const time_t *__timer) throw ();
>
>
>
>
>
>
>
>extern char *asctime_r (__const struct tm *__restrict __tp,
> char *__restrict __buf) throw ();
>
>
>extern char *ctime_r (__const time_t *__restrict __timer,
> char *__restrict __buf) throw ();
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) throw ();
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (__const time_t *__when) throw ();
># 312 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) throw ();
>
>
>extern time_t timelocal (struct tm *__tp) throw ();
>
>
>extern int dysize (int __year) throw () __attribute__ ((__const__));
># 327 "/usr/include/time.h" 3 4
>extern int nanosleep (__const struct timespec *__requested_time,
> struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
>
>
>extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
> throw ();
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
> __const struct timespec *__req,
> struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
> struct sigevent *__restrict __evp,
> timer_t *__restrict __timerid) throw ();
>
>
>extern int timer_delete (timer_t __timerid) throw ();
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
> __const struct itimerspec *__restrict __value,
> struct itimerspec *__restrict __ovalue) throw ();
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
> throw ();
>
>
>extern int timer_getoverrun (timer_t __timerid) throw ();
># 389 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 398 "/usr/include/time.h" 3 4
>extern struct tm *getdate (__const char *__string);
># 412 "/usr/include/time.h" 3 4
>extern int getdate_r (__const char *__restrict __string,
> struct tm *__restrict __resbufp);
>
>
>}
># 25 "/usr/include/pthread.h" 2 3 4
>
>
># 1 "/usr/include/signal.h" 1 3 4
># 31 "/usr/include/signal.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 34 "/usr/include/signal.h" 2 3 4
># 400 "/usr/include/signal.h" 3 4
>}
># 28 "/usr/include/pthread.h" 2 3 4
>
># 1 "/usr/include/bits/setjmp.h" 1 3 4
># 29 "/usr/include/bits/setjmp.h" 3 4
>typedef int __jmp_buf[6];
># 30 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 31 "/usr/include/pthread.h" 2 3 4
>
>
>
>enum
>{
> PTHREAD_CREATE_JOINABLE,
>
> PTHREAD_CREATE_DETACHED
>
>};
>
>
>
>enum
>{
> PTHREAD_MUTEX_TIMED_NP,
> PTHREAD_MUTEX_RECURSIVE_NP,
> PTHREAD_MUTEX_ERRORCHECK_NP,
> PTHREAD_MUTEX_ADAPTIVE_NP
>
> ,
> PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
> PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
> PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
> PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
>
>
>
> , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
>
>};
>
>
>
>
>enum
>{
> PTHREAD_MUTEX_STALLED_NP,
> PTHREAD_MUTEX_ROBUST_NP
>};
>
>
>
>
>
>enum
>{
> PTHREAD_PRIO_NONE,
> PTHREAD_PRIO_INHERIT,
> PTHREAD_PRIO_PROTECT
>};
># 113 "/usr/include/pthread.h" 3 4
>enum
>{
> PTHREAD_RWLOCK_PREFER_READER_NP,
> PTHREAD_RWLOCK_PREFER_WRITER_NP,
> PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
> PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
>};
># 143 "/usr/include/pthread.h" 3 4
>enum
>{
> PTHREAD_INHERIT_SCHED,
>
> PTHREAD_EXPLICIT_SCHED
>
>};
>
>
>
>enum
>{
> PTHREAD_SCOPE_SYSTEM,
>
> PTHREAD_SCOPE_PROCESS
>
>};
>
>
>
>enum
>{
> PTHREAD_PROCESS_PRIVATE,
>
> PTHREAD_PROCESS_SHARED
>
>};
># 178 "/usr/include/pthread.h" 3 4
>struct _pthread_cleanup_buffer
>{
> void (*__routine) (void *);
> void *__arg;
> int __canceltype;
> struct _pthread_cleanup_buffer *__prev;
>};
>
>
>enum
>{
> PTHREAD_CANCEL_ENABLE,
>
> PTHREAD_CANCEL_DISABLE
>
>};
>enum
>{
> PTHREAD_CANCEL_DEFERRED,
>
> PTHREAD_CANCEL_ASYNCHRONOUS
>
>};
># 216 "/usr/include/pthread.h" 3 4
>extern "C" {
>
>
>
>
>extern int pthread_create (pthread_t *__restrict __newthread,
> __const pthread_attr_t *__restrict __attr,
> void *(*__start_routine) (void *),
> void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern int pthread_join (pthread_t __th, void **__thread_return);
>
>
>
>
>extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
>
>
>
>
>
>
>
>extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
> __const struct timespec *__abstime);
>
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) throw ();
>
>
>
>extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
> int *__detachstate)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
> int __detachstate)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr,
> size_t *__guardsize)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
> size_t __guardsize)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
> __attr,
> struct sched_param *__restrict __param)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
> __const struct sched_param *__restrict
> __param) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
> __attr, int *__restrict __policy)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
> __attr, int *__restrict __inherit)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
> int __inherit)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
> int *__restrict __scope)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
> __attr, void **__restrict __stackaddr)
> throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
> void *__stackaddr)
> throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
>
>
>extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
> __attr, size_t *__restrict __stacksize)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
> size_t __stacksize)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
> void **__restrict __stackaddr,
> size_t *__restrict __stacksize)
> throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
> size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
> size_t __cpusetsize,
> __const cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern int pthread_attr_getaffinity_np (__const pthread_attr_t *__attr,
> size_t __cpusetsize,
> cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
> __const struct sched_param *__param)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
> int *__restrict __policy,
> struct sched_param *__restrict __param)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
> throw ();
>
>
>
>
>extern int pthread_getconcurrency (void) throw ();
>
>
>extern int pthread_setconcurrency (int __level) throw ();
>
>
>
>
>
>
>
>extern int pthread_yield (void) throw ();
>
>
>
>
>extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
> __const cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
> cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (3)));
># 462 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
> void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 474 "/usr/include/pthread.h" 3 4
>extern int pthread_setcancelstate (int __state, int *__oldstate);
>
>
>
>extern int pthread_setcanceltype (int __type, int *__oldtype);
>
>
>extern int pthread_cancel (pthread_t __th);
>
>
>
>
>extern void pthread_testcancel (void);
>
>
>
>
>typedef struct
>{
> struct
> {
> __jmp_buf __cancel_jmp_buf;
> int __mask_was_saved;
> } __cancel_jmp_buf[1];
> void *__pad[4];
>} __pthread_unwind_buf_t __attribute__ ((__aligned__));
># 508 "/usr/include/pthread.h" 3 4
>struct __pthread_cleanup_frame
>{
> void (*__cancel_routine) (void *);
> void *__cancel_arg;
> int __do_it;
> int __cancel_type;
>};
>
>
>
>
>class __pthread_cleanup_class
>{
> void (*__cancel_routine) (void *);
> void *__cancel_arg;
> int __do_it;
> int __cancel_type;
>
> public:
> __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
> : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
> ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
> void __setdoit (int __newval) { __do_it = __newval; }
> void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
> &__cancel_type); }
> void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
>};
># 708 "/usr/include/pthread.h" 3 4
>struct __jmp_buf_tag;
>extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__mutex,
> __const pthread_mutexattr_t *__mutexattr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
> __const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int pthread_mutex_getprioceiling (__const pthread_mutex_t *
> __restrict __mutex,
> int *__restrict __prioceiling)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
> int __prioceiling,
> int *__restrict __old_ceiling)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
> __attr, int *__restrict __kind)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprotocol (__const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __protocol)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
> int __protocol)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprioceiling (__const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __prioceiling)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
> int __prioceiling)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int pthread_mutexattr_getrobust_np (__const pthread_mutexattr_t *__attr,
> int *__robustness)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
> int __robustness)
> throw () __attribute__ ((__nonnull__ (1)));
># 842 "/usr/include/pthread.h" 3 4
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
> __const pthread_rwlockattr_t *__restrict
> __attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
> __const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
> __const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pref)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
> int __pref) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
> __const pthread_condattr_t *__restrict
> __cond_attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_signal (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_broadcast (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex)
> __attribute__ ((__nonnull__ (1, 2)));
># 954 "/usr/include/pthread.h" 3 4
>extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex,
> __const struct timespec *__restrict
> __abstime) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_getpshared (__const pthread_condattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
> int __pshared) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_condattr_getclock (__const pthread_condattr_t *
> __restrict __attr,
> __clockid_t *__restrict __clock_id)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
> __clockid_t __clock_id)
> throw () __attribute__ ((__nonnull__ (1)));
># 998 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_lock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
> __const pthread_barrierattr_t *__restrict
> __attr, unsigned int __count)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
># 1065 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
> void (*__destr_function) (void *))
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_key_delete (pthread_key_t __key) throw ();
>
>
>extern void *pthread_getspecific (pthread_key_t __key) throw ();
>
>
>extern int pthread_setspecific (pthread_key_t __key,
> __const void *__pointer) throw () ;
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
> __clockid_t *__clock_id)
> throw () __attribute__ ((__nonnull__ (2)));
># 1099 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
> void (*__parent) (void),
> void (*__child) (void)) throw ();
>
>
>
>
>extern __inline int
>pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
>{
> return __thread1 == __thread2;
>}
>
>
>}
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 2 3
># 1 "/usr/include/unistd.h" 1 3 4
># 28 "/usr/include/unistd.h" 3 4
>extern "C" {
># 171 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 172 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 176 "/usr/include/unistd.h" 2 3 4
># 195 "/usr/include/unistd.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 196 "/usr/include/unistd.h" 2 3 4
># 236 "/usr/include/unistd.h" 3 4
>typedef __intptr_t intptr_t;
>
>
>
>
>
>
>typedef __socklen_t socklen_t;
># 256 "/usr/include/unistd.h" 3 4
>extern int access (__const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (__const char *__name, int __type)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (__const char *__name, int __type)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, __const char *__file, int __type, int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
># 299 "/usr/include/unistd.h" 3 4
>extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
># 310 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
> throw ();
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
>
>
>
>
>
>extern ssize_t write (int __fd, __const void *__buf, size_t __n) ;
># 341 "/usr/include/unistd.h" 3 4
>extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
> __off_t __offset) ;
>
>
>
>
>
>
>extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
> __off_t __offset) ;
># 369 "/usr/include/unistd.h" 3 4
>extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
> __off64_t __offset) ;
>
>
>extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n,
> __off64_t __offset) ;
>
>
>
>
>
>
>
>extern int pipe (int __pipedes[2]) throw () ;
># 391 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) throw ();
># 403 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
> throw ();
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 427 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
>
>
>
>
>extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>extern int fchownat (int __fd, __const char *__file, __uid_t __owner,
> __gid_t __group, int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchdir (int __fd) throw () ;
># 469 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) throw () ;
>
>
>
>
>
>extern char *get_current_dir_name (void) throw ();
>
>
>
>
>
>
>extern char *getwd (char *__buf)
> throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
>
>
>
>
>extern int dup (int __fd) throw () ;
>
>
>extern int dup2 (int __fd, int __fd2) throw ();
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (__const char *__path, char *__const __argv[],
> char *__const __envp[]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
> throw ();
>
>
>
>
>extern int execv (__const char *__path, char *__const __argv[])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execle (__const char *__path, __const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execl (__const char *__path, __const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execvp (__const char *__file, char *__const __argv[])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int execlp (__const char *__file, __const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int nice (int __inc) throw () ;
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 26 "/usr/include/bits/confname.h" 3 4
>enum
> {
> _PC_LINK_MAX,
>
> _PC_MAX_CANON,
>
> _PC_MAX_INPUT,
>
> _PC_NAME_MAX,
>
> _PC_PATH_MAX,
>
> _PC_PIPE_BUF,
>
> _PC_CHOWN_RESTRICTED,
>
> _PC_NO_TRUNC,
>
> _PC_VDISABLE,
>
> _PC_SYNC_IO,
>
> _PC_ASYNC_IO,
>
> _PC_PRIO_IO,
>
> _PC_SOCK_MAXBUF,
>
> _PC_FILESIZEBITS,
>
> _PC_REC_INCR_XFER_SIZE,
>
> _PC_REC_MAX_XFER_SIZE,
>
> _PC_REC_MIN_XFER_SIZE,
>
> _PC_REC_XFER_ALIGN,
>
> _PC_ALLOC_SIZE_MIN,
>
> _PC_SYMLINK_MAX,
>
> _PC_2_SYMLINKS
>
> };
>
>
>enum
> {
> _SC_ARG_MAX,
>
> _SC_CHILD_MAX,
>
> _SC_CLK_TCK,
>
> _SC_NGROUPS_MAX,
>
> _SC_OPEN_MAX,
>
> _SC_STREAM_MAX,
>
> _SC_TZNAME_MAX,
>
> _SC_JOB_CONTROL,
>
> _SC_SAVED_IDS,
>
> _SC_REALTIME_SIGNALS,
>
> _SC_PRIORITY_SCHEDULING,
>
> _SC_TIMERS,
>
> _SC_ASYNCHRONOUS_IO,
>
> _SC_PRIORITIZED_IO,
>
> _SC_SYNCHRONIZED_IO,
>
> _SC_FSYNC,
>
> _SC_MAPPED_FILES,
>
> _SC_MEMLOCK,
>
> _SC_MEMLOCK_RANGE,
>
> _SC_MEMORY_PROTECTION,
>
> _SC_MESSAGE_PASSING,
>
> _SC_SEMAPHORES,
>
> _SC_SHARED_MEMORY_OBJECTS,
>
> _SC_AIO_LISTIO_MAX,
>
> _SC_AIO_MAX,
>
> _SC_AIO_PRIO_DELTA_MAX,
>
> _SC_DELAYTIMER_MAX,
>
> _SC_MQ_OPEN_MAX,
>
> _SC_MQ_PRIO_MAX,
>
> _SC_VERSION,
>
> _SC_PAGESIZE,
>
>
> _SC_RTSIG_MAX,
>
> _SC_SEM_NSEMS_MAX,
>
> _SC_SEM_VALUE_MAX,
>
> _SC_SIGQUEUE_MAX,
>
> _SC_TIMER_MAX,
>
>
>
>
> _SC_BC_BASE_MAX,
>
> _SC_BC_DIM_MAX,
>
> _SC_BC_SCALE_MAX,
>
> _SC_BC_STRING_MAX,
>
> _SC_COLL_WEIGHTS_MAX,
>
> _SC_EQUIV_CLASS_MAX,
>
> _SC_EXPR_NEST_MAX,
>
> _SC_LINE_MAX,
>
> _SC_RE_DUP_MAX,
>
> _SC_CHARCLASS_NAME_MAX,
>
>
> _SC_2_VERSION,
>
> _SC_2_C_BIND,
>
> _SC_2_C_DEV,
>
> _SC_2_FORT_DEV,
>
> _SC_2_FORT_RUN,
>
> _SC_2_SW_DEV,
>
> _SC_2_LOCALEDEF,
>
>
> _SC_PII,
>
> _SC_PII_XTI,
>
> _SC_PII_SOCKET,
>
> _SC_PII_INTERNET,
>
> _SC_PII_OSI,
>
> _SC_POLL,
>
> _SC_SELECT,
>
> _SC_UIO_MAXIOV,
>
> _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
> _SC_PII_INTERNET_STREAM,
>
> _SC_PII_INTERNET_DGRAM,
>
> _SC_PII_OSI_COTS,
>
> _SC_PII_OSI_CLTS,
>
> _SC_PII_OSI_M,
>
> _SC_T_IOV_MAX,
>
>
>
> _SC_THREADS,
>
> _SC_THREAD_SAFE_FUNCTIONS,
>
> _SC_GETGR_R_SIZE_MAX,
>
> _SC_GETPW_R_SIZE_MAX,
>
> _SC_LOGIN_NAME_MAX,
>
> _SC_TTY_NAME_MAX,
>
> _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
> _SC_THREAD_KEYS_MAX,
>
> _SC_THREAD_STACK_MIN,
>
> _SC_THREAD_THREADS_MAX,
>
> _SC_THREAD_ATTR_STACKADDR,
>
> _SC_THREAD_ATTR_STACKSIZE,
>
> _SC_THREAD_PRIORITY_SCHEDULING,
>
> _SC_THREAD_PRIO_INHERIT,
>
> _SC_THREAD_PRIO_PROTECT,
>
> _SC_THREAD_PROCESS_SHARED,
>
>
> _SC_NPROCESSORS_CONF,
>
> _SC_NPROCESSORS_ONLN,
>
> _SC_PHYS_PAGES,
>
> _SC_AVPHYS_PAGES,
>
> _SC_ATEXIT_MAX,
>
> _SC_PASS_MAX,
>
>
> _SC_XOPEN_VERSION,
>
> _SC_XOPEN_XCU_VERSION,
>
> _SC_XOPEN_UNIX,
>
> _SC_XOPEN_CRYPT,
>
> _SC_XOPEN_ENH_I18N,
>
> _SC_XOPEN_SHM,
>
>
> _SC_2_CHAR_TERM,
>
> _SC_2_C_VERSION,
>
> _SC_2_UPE,
>
>
> _SC_XOPEN_XPG2,
>
> _SC_XOPEN_XPG3,
>
> _SC_XOPEN_XPG4,
>
>
> _SC_CHAR_BIT,
>
> _SC_CHAR_MAX,
>
> _SC_CHAR_MIN,
>
> _SC_INT_MAX,
>
> _SC_INT_MIN,
>
> _SC_LONG_BIT,
>
> _SC_WORD_BIT,
>
> _SC_MB_LEN_MAX,
>
> _SC_NZERO,
>
> _SC_SSIZE_MAX,
>
> _SC_SCHAR_MAX,
>
> _SC_SCHAR_MIN,
>
> _SC_SHRT_MAX,
>
> _SC_SHRT_MIN,
>
> _SC_UCHAR_MAX,
>
> _SC_UINT_MAX,
>
> _SC_ULONG_MAX,
>
> _SC_USHRT_MAX,
>
>
> _SC_NL_ARGMAX,
>
> _SC_NL_LANGMAX,
>
> _SC_NL_MSGMAX,
>
> _SC_NL_NMAX,
>
> _SC_NL_SETMAX,
>
> _SC_NL_TEXTMAX,
>
>
> _SC_XBS5_ILP32_OFF32,
>
> _SC_XBS5_ILP32_OFFBIG,
>
> _SC_XBS5_LP64_OFF64,
>
> _SC_XBS5_LPBIG_OFFBIG,
>
>
> _SC_XOPEN_LEGACY,
>
> _SC_XOPEN_REALTIME,
>
> _SC_XOPEN_REALTIME_THREADS,
>
>
> _SC_ADVISORY_INFO,
>
> _SC_BARRIERS,
>
> _SC_BASE,
>
> _SC_C_LANG_SUPPORT,
>
> _SC_C_LANG_SUPPORT_R,
>
> _SC_CLOCK_SELECTION,
>
> _SC_CPUTIME,
>
> _SC_THREAD_CPUTIME,
>
> _SC_DEVICE_IO,
>
> _SC_DEVICE_SPECIFIC,
>
> _SC_DEVICE_SPECIFIC_R,
>
> _SC_FD_MGMT,
>
> _SC_FIFO,
>
> _SC_PIPE,
>
> _SC_FILE_ATTRIBUTES,
>
> _SC_FILE_LOCKING,
>
> _SC_FILE_SYSTEM,
>
> _SC_MONOTONIC_CLOCK,
>
> _SC_MULTI_PROCESS,
>
> _SC_SINGLE_PROCESS,
>
> _SC_NETWORKING,
>
> _SC_READER_WRITER_LOCKS,
>
> _SC_SPIN_LOCKS,
>
> _SC_REGEXP,
>
> _SC_REGEX_VERSION,
>
> _SC_SHELL,
>
> _SC_SIGNALS,
>
> _SC_SPAWN,
>
> _SC_SPORADIC_SERVER,
>
> _SC_THREAD_SPORADIC_SERVER,
>
> _SC_SYSTEM_DATABASE,
>
> _SC_SYSTEM_DATABASE_R,
>
> _SC_TIMEOUTS,
>
> _SC_TYPED_MEMORY_OBJECTS,
>
> _SC_USER_GROUPS,
>
> _SC_USER_GROUPS_R,
>
> _SC_2_PBS,
>
> _SC_2_PBS_ACCOUNTING,
>
> _SC_2_PBS_LOCATE,
>
> _SC_2_PBS_MESSAGE,
>
> _SC_2_PBS_TRACK,
>
> _SC_SYMLOOP_MAX,
>
> _SC_STREAMS,
>
> _SC_2_PBS_CHECKPOINT,
>
>
> _SC_V6_ILP32_OFF32,
>
> _SC_V6_ILP32_OFFBIG,
>
> _SC_V6_LP64_OFF64,
>
> _SC_V6_LPBIG_OFFBIG,
>
>
> _SC_HOST_NAME_MAX,
>
> _SC_TRACE,
>
> _SC_TRACE_EVENT_FILTER,
>
> _SC_TRACE_INHERIT,
>
> _SC_TRACE_LOG,
>
>
> _SC_LEVEL1_ICACHE_SIZE,
>
> _SC_LEVEL1_ICACHE_ASSOC,
>
> _SC_LEVEL1_ICACHE_LINESIZE,
>
> _SC_LEVEL1_DCACHE_SIZE,
>
> _SC_LEVEL1_DCACHE_ASSOC,
>
> _SC_LEVEL1_DCACHE_LINESIZE,
>
> _SC_LEVEL2_CACHE_SIZE,
>
> _SC_LEVEL2_CACHE_ASSOC,
>
> _SC_LEVEL2_CACHE_LINESIZE,
>
> _SC_LEVEL3_CACHE_SIZE,
>
> _SC_LEVEL3_CACHE_ASSOC,
>
> _SC_LEVEL3_CACHE_LINESIZE,
>
> _SC_LEVEL4_CACHE_SIZE,
>
> _SC_LEVEL4_CACHE_ASSOC,
>
> _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
> _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
> _SC_RAW_SOCKETS
>
> };
>
>
>enum
> {
> _CS_PATH,
>
>
> _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
> _CS_GNU_LIBC_VERSION,
>
> _CS_GNU_LIBPTHREAD_VERSION,
>
>
> _CS_LFS_CFLAGS = 1000,
>
> _CS_LFS_LDFLAGS,
>
> _CS_LFS_LIBS,
>
> _CS_LFS_LINTFLAGS,
>
> _CS_LFS64_CFLAGS,
>
> _CS_LFS64_LDFLAGS,
>
> _CS_LFS64_LIBS,
>
> _CS_LFS64_LINTFLAGS,
>
>
> _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
> _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
> _CS_XBS5_ILP32_OFF32_LIBS,
>
> _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_LIBS,
>
> _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_XBS5_LP64_OFF64_CFLAGS,
>
> _CS_XBS5_LP64_OFF64_LDFLAGS,
>
> _CS_XBS5_LP64_OFF64_LIBS,
>
> _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
> _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
> _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
> _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
> _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_LIBS,
>
> _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
>
> };
># 553 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (__const char *__path, int __name)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) throw ();
>
>
>extern long int sysconf (int __name) throw () __attribute__ ((__const__));
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
>
>
>
>
>extern __pid_t getpid (void) throw ();
>
>
>extern __pid_t getppid (void) throw ();
>
>
>
>
>extern __pid_t getpgrp (void) throw ();
># 589 "/usr/include/unistd.h" 3 4
>extern __pid_t __getpgid (__pid_t __pid) throw ();
>
>extern __pid_t getpgid (__pid_t __pid) throw ();
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
># 615 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) throw ();
># 632 "/usr/include/unistd.h" 3 4
>extern __pid_t setsid (void) throw ();
>
>
>
>extern __pid_t getsid (__pid_t __pid) throw ();
>
>
>
>extern __uid_t getuid (void) throw ();
>
>
>extern __uid_t geteuid (void) throw ();
>
>
>extern __gid_t getgid (void) throw ();
>
>
>extern __gid_t getegid (void) throw ();
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) throw () ;
>
>
>
>extern int group_member (__gid_t __gid) throw ();
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) throw ();
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) throw ();
>
>
>
>
>extern int seteuid (__uid_t __uid) throw ();
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) throw ();
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) throw ();
>
>
>
>
>extern int setegid (__gid_t __gid) throw ();
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
> throw ();
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
> throw ();
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
> throw ();
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
> throw ();
>
>
>
>
>
>
>extern __pid_t fork (void) throw ();
>
>
>
>
>
>
>extern __pid_t vfork (void) throw ();
>
>
>
>
>
>extern char *ttyname (int __fd) throw ();
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int isatty (int __fd) throw ();
>
>
>
>
>
>extern int ttyslot (void) throw ();
>
>
>
>
>extern int link (__const char *__from, __const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int linkat (int __fromfd, __const char *__from, int __tofd,
> __const char *__to, int __flags)
> throw () __attribute__ ((__nonnull__ (2, 4))) ;
>
>
>
>
>extern int symlink (__const char *__from, __const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern ssize_t readlink (__const char *__restrict __path,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int symlinkat (__const char *__from, int __tofd,
> __const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
>
>
>extern ssize_t readlinkat (int __fd, __const char *__restrict __path,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (2, 3))) ;
>
>
>
>extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, __const char *__name, int __flag)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) throw ();
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
># 835 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/getopt.h" 1 3 4
># 50 "/usr/include/getopt.h" 3 4
>extern "C" {
># 59 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 73 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 152 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
> throw ();
># 171 "/usr/include/getopt.h" 3 4
>}
># 836 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (__const char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int sethostid (long int __id) throw () ;
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>extern int setdomainname (__const char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int vhangup (void) throw ();
>
>
>extern int revoke (__const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
> size_t __offset, unsigned int __scale)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (__const char *__name) throw ();
>
>
>
>extern char *getusershell (void) throw ();
>extern void endusershell (void) throw ();
>extern void setusershell (void) throw ();
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) throw () ;
>
>
>
>
>
>
>extern int chroot (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern char *getpass (__const char *__prompt) __attribute__ ((__nonnull__ (1)));
># 921 "/usr/include/unistd.h" 3 4
>extern int fsync (int __fd);
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) throw ();
>
>
>
>
>extern int getpagesize (void) throw () __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) throw ();
>
>
>
>
>extern int truncate (__const char *__file, __off_t __length)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 958 "/usr/include/unistd.h" 3 4
>extern int truncate64 (__const char *__file, __off64_t __length)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 968 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off_t __length) throw () ;
># 978 "/usr/include/unistd.h" 3 4
>extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
># 988 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) throw () ;
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) throw ();
># 1009 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) throw ();
># 1032 "/usr/include/unistd.h" 3 4
>extern int lockf (int __fd, int __cmd, __off_t __len) ;
># 1042 "/usr/include/unistd.h" 3 4
>extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
># 1063 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes) throw ();
>
>
>
>
>
>
>
>extern char *crypt (__const char *__key, __const char *__salt)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void swab (__const void *__restrict __from, void *__restrict __to,
> ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>extern char *ctermid (char *__s) throw ();
># 1101 "/usr/include/unistd.h" 3 4
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 2 3
>
>typedef pthread_key_t __gthread_key_t;
>typedef pthread_once_t __gthread_once_t;
>typedef pthread_mutex_t __gthread_mutex_t;
>typedef pthread_mutex_t __gthread_recursive_mutex_t;
># 88 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 3
>extern __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
>extern __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
>extern __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
>extern __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
>extern __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
>extern __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
>extern __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
>extern __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
>extern __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
>
>
>extern __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
>extern __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
>extern __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
>extern __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
>extern __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
># 145 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_active_p (void)
>{
> static void *const __gthread_active_ptr
> = __extension__ (void *) &__gthrw_pthread_cancel;
> return __gthread_active_ptr != 0;
>}
># 512 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_once (__gthread_once_t *once, void (*func) (void))
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_once (once, func);
> else
> return -1;
>}
>
>static inline int
>__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
>{
> return __gthrw_pthread_key_create (key, dtor);
>}
>
>static inline int
>__gthread_key_delete (__gthread_key_t key)
>{
> return __gthrw_pthread_key_delete (key);
>}
>
>static inline void *
>__gthread_getspecific (__gthread_key_t key)
>{
> return __gthrw_pthread_getspecific (key);
>}
>
>static inline int
>__gthread_setspecific (__gthread_key_t key, const void *ptr)
>{
> return __gthrw_pthread_setspecific (key, ptr);
>}
>
>static inline int
>__gthread_mutex_lock (__gthread_mutex_t *mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_lock (mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_trylock (__gthread_mutex_t *mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_trylock (mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_unlock (__gthread_mutex_t *mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_unlock (mutex);
> else
> return 0;
>}
># 594 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
>{
> return __gthread_mutex_lock (mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
>{
> return __gthread_mutex_trylock (mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
>{
> return __gthread_mutex_unlock (mutex);
>}
># 115 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/gthr.h" 2 3
>
>
>
>
>
>
>
>#pragma GCC visibility pop
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++io.h" 2 3
>
>namespace std
>{
> typedef __gthread_mutex_t __c_lock;
>
>
> typedef FILE __c_file;
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cctype" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cctype" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cctype" 3
>
>
># 1 "/usr/include/ctype.h" 1 3 4
># 30 "/usr/include/ctype.h" 3 4
>extern "C" {
># 48 "/usr/include/ctype.h" 3 4
>enum
>{
> _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
> _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
> _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
> _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
> _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
> _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
> _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
> _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
> _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
> _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
> _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
> _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
>};
># 81 "/usr/include/ctype.h" 3 4
>extern __const unsigned short int **__ctype_b_loc (void)
> __attribute__ ((__const));
>extern __const __int32_t **__ctype_tolower_loc (void)
> __attribute__ ((__const));
>extern __const __int32_t **__ctype_toupper_loc (void)
> __attribute__ ((__const));
># 96 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) throw ();
>extern int isalpha (int) throw ();
>extern int iscntrl (int) throw ();
>extern int isdigit (int) throw ();
>extern int islower (int) throw ();
>extern int isgraph (int) throw ();
>extern int isprint (int) throw ();
>extern int ispunct (int) throw ();
>extern int isspace (int) throw ();
>extern int isupper (int) throw ();
>extern int isxdigit (int) throw ();
>
>
>
>extern int tolower (int __c) throw ();
>
>
>extern int toupper (int __c) throw ();
>
>
>
>
>
>
>
>
>extern int isblank (int) throw ();
>
>
>
>
>
>
>extern int isctype (int __c, int __mask) throw ();
>
>
>
>
>
>
>extern int isascii (int __c) throw ();
>
>
>
>extern int toascii (int __c) throw ();
>
>
>
>extern int _toupper (int) throw ();
>extern int _tolower (int) throw ();
># 247 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, __locale_t) throw ();
>extern int isalpha_l (int, __locale_t) throw ();
>extern int iscntrl_l (int, __locale_t) throw ();
>extern int isdigit_l (int, __locale_t) throw ();
>extern int islower_l (int, __locale_t) throw ();
>extern int isgraph_l (int, __locale_t) throw ();
>extern int isprint_l (int, __locale_t) throw ();
>extern int ispunct_l (int, __locale_t) throw ();
>extern int isspace_l (int, __locale_t) throw ();
>extern int isupper_l (int, __locale_t) throw ();
>extern int isxdigit_l (int, __locale_t) throw ();
>
>extern int isblank_l (int, __locale_t) throw ();
>
>
>
>extern int __tolower_l (int __c, __locale_t __l) throw ();
>extern int tolower_l (int __c, __locale_t __l) throw ();
>
>
>extern int __toupper_l (int __c, __locale_t __l) throw ();
>extern int toupper_l (int __c, __locale_t __l) throw ();
># 323 "/usr/include/ctype.h" 3 4
>}
># 52 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cctype" 2 3
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cctype" 3
>namespace std
>{
> using ::isalnum;
> using ::isalpha;
> using ::iscntrl;
> using ::isdigit;
> using ::isgraph;
> using ::islower;
> using ::isprint;
> using ::ispunct;
> using ::isspace;
> using ::isupper;
> using ::isxdigit;
> using ::tolower;
> using ::toupper;
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 1 3
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 3
> 
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ctime" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ctime" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ctime" 3
># 65 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ctime" 3
>namespace std
>{
> using ::clock_t;
> using ::time_t;
> using ::tm;
>
> using ::clock;
> using ::difftime;
> using ::mktime;
> using ::time;
> using ::asctime;
> using ::ctime;
> using ::gmtime;
> using ::localtime;
> using ::strftime;
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 2 3
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 40 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stdarg.h" 1 3 4
># 41 "/usr/include/wchar.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
># 93 "/usr/include/wchar.h" 3 4
>
>
>typedef __mbstate_t mbstate_t;
>
>
>
># 118 "/usr/include/wchar.h" 3 4
>extern "C" {
>
>
>
>
>struct tm;
>
>
>
>
>
>
>
>
>
>extern wchar_t *wcscpy (wchar_t *__restrict __dest,
> __const wchar_t *__restrict __src) throw ();
>
>extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
> __const wchar_t *__restrict __src, size_t __n)
> throw ();
>
>
>extern wchar_t *wcscat (wchar_t *__restrict __dest,
> __const wchar_t *__restrict __src) throw ();
>
>extern wchar_t *wcsncat (wchar_t *__restrict __dest,
> __const wchar_t *__restrict __src, size_t __n)
> throw ();
>
>
>extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
> throw () __attribute__ ((__pure__));
>
>extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>
>
>extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();
>
>
>extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
> size_t __n) throw ();
>
>
>
>
>
>extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
> __locale_t __loc) throw ();
>
>extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
> size_t __n, __locale_t __loc) throw ();
>
>
>
>
>
>extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();
>
>
>
>extern size_t wcsxfrm (wchar_t *__restrict __s1,
> __const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>
>
>
>
>
>extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
> __locale_t __loc) throw ();
>
>
>
>
>extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
> size_t __n, __locale_t __loc) throw ();
>
>
>extern wchar_t *wcsdup (__const wchar_t *__s) throw () __attribute__ ((__malloc__));
>
>
>
>
>extern wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
> throw () __attribute__ ((__pure__));
>
>extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
> throw () __attribute__ ((__pure__));
>
>
>extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
> throw () __attribute__ ((__pure__));
>
>extern wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept)
> throw () __attribute__ ((__pure__));
>
>extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
> throw () __attribute__ ((__pure__));
>
>
>extern wchar_t *wcstok (wchar_t *__restrict __s,
> __const wchar_t *__restrict __delim,
> wchar_t **__restrict __ptr) throw ();
>
>
>extern size_t wcslen (__const wchar_t *__s) throw () __attribute__ ((__pure__));
>
>
>
>
>extern wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
> throw () __attribute__ ((__pure__));
>
>
>
>
>extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>extern int wmemcmp (__const wchar_t *__restrict __s1,
> __const wchar_t *__restrict __s2, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
> __const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
> throw ();
>
>
>extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
>
>
>
>
>
>extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
> __const wchar_t *__restrict __s2, size_t __n)
> throw ();
>
>
>
>
>
>
>extern wint_t btowc (int __c) throw ();
>
>
>
>extern int wctob (wint_t __c) throw ();
>
>
>
>extern int mbsinit (__const mbstate_t *__ps) throw () __attribute__ ((__pure__));
>
>
>
>extern size_t mbrtowc (wchar_t *__restrict __pwc,
> __const char *__restrict __s, size_t __n,
> mbstate_t *__p) throw ();
>
>
>extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
> mbstate_t *__restrict __ps) throw ();
>
>
>extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __ps) throw ();
>extern size_t mbrlen (__const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __ps) throw ();
>
># 341 "/usr/include/wchar.h" 3 4
>extern __inline size_t
>mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
>
>{ return (__ps != __null
> ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
>
>
>
>
>
>extern size_t mbsrtowcs (wchar_t *__restrict __dst,
> __const char **__restrict __src, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsrtombs (char *__restrict __dst,
> __const wchar_t **__restrict __src, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
> __const char **__restrict __src, size_t __nmc,
> size_t __len, mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsnrtombs (char *__restrict __dst,
> __const wchar_t **__restrict __src,
> size_t __nwc, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern int wcwidth (wchar_t __c) throw ();
>
>
>
>extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();
>
>
>
>
>
>
>extern double wcstod (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>extern float wcstof (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>extern long double wcstold (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>
>
>extern long int wcstol (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base) throw ();
>
>
>
>extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>
>__extension__
>extern long long int wcstoll (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base) throw ();
>
>
>
>
>
>
>__extension__
>extern long long int wcstoq (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base) throw ();
># 467 "/usr/include/wchar.h" 3 4
>extern long int wcstol_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base,
> __locale_t __loc) throw ();
>
>extern unsigned long int wcstoul_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, __locale_t __loc) throw ();
>
>__extension__
>extern long long int wcstoll_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, __locale_t __loc) throw ();
>
>__extension__
>extern unsigned long long int wcstoull_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, __locale_t __loc)
> throw ();
>
>extern double wcstod_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, __locale_t __loc)
> throw ();
>
>extern float wcstof_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, __locale_t __loc)
> throw ();
>
>extern long double wcstold_l (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> __locale_t __loc) throw ();
>
>
>
>
>
>extern double __wcstod_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __group)
> throw ();
>extern float __wcstof_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __group)
> throw ();
>extern long double __wcstold_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __group) throw ();
>
>
>
>extern long int __wcstol_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, int __group) throw ();
>
>
>
>
>extern unsigned long int __wcstoul_internal (__const wchar_t *__restrict __npt,
> wchar_t **__restrict __endptr,
> int __base, int __group) throw ();
>
>
>
>
>__extension__
>extern long long int __wcstoll_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, int __group) throw ();
>
>
>
>
>__extension__
>extern unsigned long long int __wcstoull_internal (__const wchar_t *
> __restrict __nptr,
> wchar_t **
> __restrict __endptr,
> int __base,
> int __group) throw ();
>
>
>
>
>
>
>
>
>extern __inline double
>wcstod (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ()
>
>{ return __wcstod_internal (__nptr, __endptr, 0); }
>extern __inline long int
>wcstol (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ()
>
>{ return __wcstol_internal (__nptr, __endptr, __base, 0); }
>extern __inline unsigned long int
>wcstoul (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ()
>
>{ return __wcstoul_internal (__nptr, __endptr, __base, 0); }
>
>
>
>extern __inline float
>wcstof (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ()
>
>{ return __wcstof_internal (__nptr, __endptr, 0); }
>
>extern __inline long double
>wcstold (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ()
>
>{ return __wcstold_internal (__nptr, __endptr, 0); }
>
>__extension__
>extern __inline long long int
>wcstoq (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ()
>
>{ return __wcstoll_internal (__nptr, __endptr, __base, 0); }
>__extension__
>extern __inline unsigned long long int
>wcstouq (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ()
>
>{ return __wcstoull_internal (__nptr, __endptr, __base, 0); }
>
>
>
>
>
>
>
>extern wchar_t *wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ();
>
>
>
>extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
> throw ();
># 607 "/usr/include/wchar.h" 3 4
>extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
>
>
>
>
>
>
>extern int fwide (__FILE *__fp, int __mode) throw ();
>
>
>
>
>
>
>extern int fwprintf (__FILE *__restrict __stream,
> __const wchar_t *__restrict __format, ...)
> ;
>
>
>
>
>extern int wprintf (__const wchar_t *__restrict __format, ...)
> ;
>
>extern int swprintf (wchar_t *__restrict __s, size_t __n,
> __const wchar_t *__restrict __format, ...)
> throw () ;
>
>
>
>
>
>extern int vfwprintf (__FILE *__restrict __s,
> __const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>
>
>extern int vwprintf (__const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>extern int vswprintf (wchar_t *__restrict __s, size_t __n,
> __const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> throw () ;
>
>
>
>
>
>
>extern int fwscanf (__FILE *__restrict __stream,
> __const wchar_t *__restrict __format, ...)
> ;
>
>
>
>
>extern int wscanf (__const wchar_t *__restrict __format, ...)
> ;
>
>extern int swscanf (__const wchar_t *__restrict __s,
> __const wchar_t *__restrict __format, ...)
> throw () ;
>
>
>
>
>
>
>
>
>
>
>
>extern int vfwscanf (__FILE *__restrict __s,
> __const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>
>
>extern int vwscanf (__const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>extern int vswscanf (__const wchar_t *__restrict __s,
> __const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> throw () ;
>
>
>
>
>
>
>
>
>
>
>extern wint_t fgetwc (__FILE *__stream);
>extern wint_t getwc (__FILE *__stream);
>
>
>
>
>
>extern wint_t getwchar (void);
>
>
>
>
>
>
>extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
>extern wint_t putwc (wchar_t __wc, __FILE *__stream);
>
>
>
>
>
>extern wint_t putwchar (wchar_t __wc);
>
>
>
>
>
>
>
>extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
> __FILE *__restrict __stream);
>
>
>
>
>
>extern int fputws (__const wchar_t *__restrict __ws,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
>
># 768 "/usr/include/wchar.h" 3 4
>extern wint_t getwc_unlocked (__FILE *__stream);
>extern wint_t getwchar_unlocked (void);
>
>
>
>
>
>
>
>extern wint_t fgetwc_unlocked (__FILE *__stream);
>
>
>
>
>
>
>
>extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
># 794 "/usr/include/wchar.h" 3 4
>extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
>extern wint_t putwchar_unlocked (wchar_t __wc);
># 804 "/usr/include/wchar.h" 3 4
>extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern int fputws_unlocked (__const wchar_t *__restrict __ws,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
> __const wchar_t *__restrict __format,
> __const struct tm *__restrict __tp) throw ();
>
>
>
>
>
>
>
>extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
> __const wchar_t *__restrict __format,
> __const struct tm *__restrict __tp,
> __locale_t __loc) throw ();
># 858 "/usr/include/wchar.h" 3 4
>}
># 56 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 2 3
># 70 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 3
>namespace std
>{
> using ::mbstate_t;
>}
># 142 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 3
>namespace std
>{
> using ::wint_t;
>
> using ::btowc;
> using ::fgetwc;
> using ::fgetws;
> using ::fputwc;
> using ::fputws;
> using ::fwide;
> using ::fwprintf;
> using ::fwscanf;
> using ::getwc;
> using ::getwchar;
> using ::mbrlen;
> using ::mbrtowc;
> using ::mbsinit;
> using ::mbsrtowcs;
> using ::putwc;
> using ::putwchar;
> using ::swprintf;
> using ::swscanf;
> using ::ungetwc;
> using ::vfwprintf;
>
> using ::vfwscanf;
>
> using ::vswprintf;
>
> using ::vswscanf;
>
> using ::vwprintf;
>
> using ::vwscanf;
>
> using ::wcrtomb;
> using ::wcscat;
> using ::wcscmp;
> using ::wcscoll;
> using ::wcscpy;
> using ::wcscspn;
> using ::wcsftime;
> using ::wcslen;
> using ::wcsncat;
> using ::wcsncmp;
> using ::wcsncpy;
> using ::wcsrtombs;
> using ::wcsspn;
> using ::wcstod;
>
> using ::wcstof;
>
> using ::wcstok;
> using ::wcstol;
> using ::wcstoul;
> using ::wcsxfrm;
> using ::wctob;
> using ::wmemcmp;
> using ::wmemcpy;
> using ::wmemmove;
> using ::wmemset;
> using ::wprintf;
> using ::wscanf;
>
> using ::wcschr;
>
> inline wchar_t*
> wcschr(wchar_t* __p, wchar_t __c)
> { return wcschr(const_cast<const wchar_t*>(__p), __c); }
>
> using ::wcspbrk;
>
> inline wchar_t*
> wcspbrk(wchar_t* __s1, const wchar_t* __s2)
> { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
>
> using ::wcsrchr;
>
> inline wchar_t*
> wcsrchr(wchar_t* __p, wchar_t __c)
> { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
>
> using ::wcsstr;
>
> inline wchar_t*
> wcsstr(wchar_t* __s1, const wchar_t* __s2)
> { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
>
> using ::wmemchr;
>
> inline wchar_t*
> wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
> { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
>}
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
> using ::wcstold;
># 259 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwchar" 3
> using ::wcstoll;
> using ::wcstoull;
>
>}
>
>namespace std
>{
> using __gnu_cxx::wcstold;
> using __gnu_cxx::wcstoll;
> using __gnu_cxx::wcstoull;
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 2 3
>
>
># 1 "/usr/include/stdint.h" 1 3 4
># 28 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/stdint.h" 2 3 4
># 49 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>
>
>__extension__
>typedef unsigned long long int uint64_t;
>
>
>
>
>
>
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>
>
>__extension__
>typedef long long int int_least64_t;
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>
>
>__extension__
>typedef unsigned long long int uint_least64_t;
>
>
>
>
>
>
>typedef signed char int_fast8_t;
>
>
>
>
>
>typedef int int_fast16_t;
>typedef int int_fast32_t;
>__extension__
>typedef long long int int_fast64_t;
>
>
>
>typedef unsigned char uint_fast8_t;
>
>
>
>
>
>typedef unsigned int uint_fast16_t;
>typedef unsigned int uint_fast32_t;
>__extension__
>typedef unsigned long long int uint_fast64_t;
># 129 "/usr/include/stdint.h" 3 4
>typedef unsigned int uintptr_t;
># 138 "/usr/include/stdint.h" 3 4
>__extension__
>typedef long long int intmax_t;
>__extension__
>typedef unsigned long long int uintmax_t;
># 50 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 2 3
>
>
>namespace std
>{
># 72 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 3
> typedef int64_t streamoff;
>
>
>
>
>
> typedef ptrdiff_t streamsize;
>
> template<typename _StateT>
> class fpos;
># 94 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 3
> template<typename _StateT>
> class fpos
> {
> private:
> streamoff _M_off;
> _StateT _M_state;
>
> public:
>
>
>
>
> fpos()
> : _M_off(0), _M_state() { }
># 116 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/postypes.h" 3
> fpos(streamoff __off)
> : _M_off(__off), _M_state() { }
>
>
> operator streamoff() const { return _M_off; }
>
>
> void
> state(_StateT __st)
> { _M_state = __st; }
>
>
> _StateT
> state() const
> { return _M_state; }
>
>
>
>
>
>
> bool
> operator==(const fpos& __other) const
> { return _M_off == __other._M_off; }
>
>
> bool
> operator!=(const fpos& __other) const
> { return _M_off != __other._M_off; }
>
>
>
>
>
> fpos&
> operator+=(streamoff __off)
> {
> _M_off += __off;
> return *this;
> }
>
>
>
>
>
> fpos&
> operator-=(streamoff __off)
> {
> _M_off -= __off;
> return *this;
> }
>
>
>
>
>
>
>
> fpos
> operator+(streamoff __off) const
> {
> fpos __pos(*this);
> __pos += __off;
> return __pos;
> }
>
>
>
>
>
>
>
> fpos
> operator-(streamoff __off) const
> {
> fpos __pos(*this);
> __pos -= __off;
> return __pos;
> }
>
>
>
>
>
>
> streamoff
> operator-(const fpos& __other) const
> { return _M_off - __other._M_off; }
> };
>
>
>
>
>
> typedef fpos<mbstate_t> streampos;
>
> typedef fpos<mbstate_t> wstreampos;
>}
># 50 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/functexcept.h" 1 3
># 41 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/functexcept.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/exception_defines.h" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/functexcept.h" 2 3
>
>namespace std
>{
>
> void
> __throw_bad_exception(void) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_alloc(void) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_cast(void) __attribute__((__noreturn__));
>
> void
> __throw_bad_typeid(void) __attribute__((__noreturn__));
>
>
> void
> __throw_logic_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_domain_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_invalid_argument(const char*) __attribute__((__noreturn__));
>
> void
> __throw_length_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_out_of_range(const char*) __attribute__((__noreturn__));
>
> void
> __throw_runtime_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_range_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_overflow_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_underflow_error(const char*) __attribute__((__noreturn__));
>
>
> void
> __throw_ios_failure(const char*) __attribute__((__noreturn__));
>}
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 2 3
>
>namespace std
>{
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ios;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_streambuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_istream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ostream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_iostream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_stringbuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_istringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_ostringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_stringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_filebuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ifstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ofstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_fstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class istreambuf_iterator;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class ostreambuf_iterator;
>
>
>
> class ios_base;
># 135 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iosfwd" 3
> typedef basic_ios<char> ios;
> typedef basic_streambuf<char> streambuf;
> typedef basic_istream<char> istream;
> typedef basic_ostream<char> ostream;
> typedef basic_iostream<char> iostream;
> typedef basic_stringbuf<char> stringbuf;
> typedef basic_istringstream<char> istringstream;
> typedef basic_ostringstream<char> ostringstream;
> typedef basic_stringstream<char> stringstream;
> typedef basic_filebuf<char> filebuf;
> typedef basic_ifstream<char> ifstream;
> typedef basic_ofstream<char> ofstream;
> typedef basic_fstream<char> fstream;
>
>
> typedef basic_ios<wchar_t> wios;
> 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;
>
>
>}
># 70 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_pair.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_pair.h" 3
>namespace std
>{
>
> template<class _T1, class _T2>
> struct pair
> {
> typedef _T1 first_type;
> typedef _T2 second_type;
>
> _T1 first;
> _T2 second;
>
>
>
>
>
> pair()
> : first(), second() { }
>
>
> pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
>
>
> template<class _U1, class _U2>
> pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
> };
>
>
> template<class _T1, class _T2>
> inline bool
> operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first == __y.first && __x.second == __y.second; }
>
>
> template<class _T1, class _T2>
> inline bool
> operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first < __y.first
> || (!(__y.first < __x.first) && __x.second < __y.second); }
>
>
> template<class _T1, class _T2>
> inline bool
> operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x == __y); }
>
>
> template<class _T1, class _T2>
> inline bool
> operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __y < __x; }
>
>
> template<class _T1, class _T2>
> inline bool
> operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__y < __x); }
>
>
> template<class _T1, class _T2>
> inline bool
> operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x < __y); }
># 142 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_pair.h" 3
> template<class _T1, class _T2>
> inline pair<_T1, _T2>
> make_pair(_T1 __x, _T2 __y)
> { return pair<_T1, _T2>(__x, __y); }
>}
># 71 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/cpp_type_traits.h" 1 3
># 41 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/cpp_type_traits.h" 3
> 
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/cpp_type_traits.h" 3
># 75 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/cpp_type_traits.h" 3
>namespace __gnu_internal
>{
> typedef char __one;
> typedef char __two[2];
>
> template<typename _Tp>
> __one __test_type(int _Tp::*);
> template<typename _Tp>
> __two& __test_type(...);
>}
>
>
>namespace __gnu_cxx
>{
> template<typename _Iterator, typename _Container>
> class __normal_iterator;
>}
>
>struct __true_type { };
>struct __false_type { };
>
>namespace std
>{
> template<bool>
> struct __truth_type
> { typedef __false_type __type; };
>
> template<>
> struct __truth_type<true>
> { typedef __true_type __type; };
>
>
>
> template<class _Sp, class _Tp>
> struct __traitor
> {
> enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
> typedef typename __truth_type<__value>::__type __type;
> };
>
>
> template<typename, typename>
> struct __are_same
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __are_same<_Tp, _Tp>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename, bool>
> struct __enable_if
> {
> };
>
> template<typename _Tp>
> struct __enable_if<_Tp, true>
> {
> typedef _Tp __type;
> };
>
>
> template<typename _Tp>
> struct __is_void
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_void<void>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_integer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
>
>
> template<>
> struct __is_integer<bool>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<short>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned short>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<int>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned int>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<long long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned long long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_floating
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
> template<>
> struct __is_floating<float>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<long double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_pointer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __is_pointer<_Tp*>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_normal_iterator
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Iterator, typename _Container>
> struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
> _Container> >
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_arithmetic
> : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_fundamental
> : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_scalar
> : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_pod
> {
> enum
> {
> __value = (sizeof(__gnu_internal::__test_type<_Tp>(0))
> != sizeof(__gnu_internal::__one))
> };
> };
>
>
>
>
> template<typename _Tp>
> struct __is_empty
> {
> private:
> template<typename>
> struct __first { };
> template<typename _Up>
> struct __second
> : public _Up { };
>
> public:
> enum
> {
> __value = sizeof(__first<_Tp>) == sizeof(__second<_Tp>)
> };
> };
>
>}
># 72 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_types.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_types.h" 3
> 
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_types.h" 3
>
>namespace std
>{
># 80 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_types.h" 3
> struct input_iterator_tag {};
>
> struct output_iterator_tag {};
>
> struct forward_iterator_tag : public input_iterator_tag {};
>
>
> struct bidirectional_iterator_tag : public forward_iterator_tag {};
>
>
> struct random_access_iterator_tag : public bidirectional_iterator_tag {};
># 104 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_types.h" 3
> template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
> typename _Pointer = _Tp*, typename _Reference = _Tp&>
> struct iterator
> {
>
> typedef _Category iterator_category;
>
> typedef _Tp value_type;
>
> typedef _Distance difference_type;
>
> typedef _Pointer pointer;
>
> typedef _Reference reference;
> };
>
>
>
>
>
>
>
> template<typename _Iterator>
> struct iterator_traits
> {
> typedef typename _Iterator::iterator_category iterator_category;
> typedef typename _Iterator::value_type value_type;
> typedef typename _Iterator::difference_type difference_type;
> typedef typename _Iterator::pointer pointer;
> typedef typename _Iterator::reference reference;
> };
>
> template<typename _Tp>
> struct iterator_traits<_Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef _Tp& reference;
> };
>
> template<typename _Tp>
> struct iterator_traits<const _Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
> };
>
>
>
>
>
>
>
> template<typename _Iter>
> inline typename iterator_traits<_Iter>::iterator_category
> __iterator_category(const _Iter&)
> { return typename iterator_traits<_Iter>::iterator_category(); }
>
>}
># 73 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_funcs.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_funcs.h" 3
> 
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_funcs.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/concept_check.h" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/concept_check.h" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/concept_check.h" 3
># 69 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_funcs.h" 2 3
>
>namespace std
>{
> template<typename _InputIterator>
> inline typename iterator_traits<_InputIterator>::difference_type
> __distance(_InputIterator __first, _InputIterator __last,
> input_iterator_tag)
> {
>
> 
>
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> while (__first != __last)
> {
> ++__first;
> ++__n;
> }
> return __n;
> }
>
> template<typename _RandomAccessIterator>
> inline typename iterator_traits<_RandomAccessIterator>::difference_type
> __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
> return __last - __first;
> }
># 112 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator>
> inline typename iterator_traits<_InputIterator>::difference_type
> distance(_InputIterator __first, _InputIterator __last)
> {
>
> return std::__distance(__first, __last,
> std::__iterator_category(__first));
> }
>
> template<typename _InputIterator, typename _Distance>
> inline void
> __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
> {
>
> 
> while (__n--)
> ++__i;
> }
>
> template<typename _BidirectionalIterator, typename _Distance>
> inline void
> __advance(_BidirectionalIterator& __i, _Distance __n,
> bidirectional_iterator_tag)
> {
>
> 
>
> if (__n > 0)
> while (__n--)
> ++__i;
> else
> while (__n++)
> --__i;
> }
>
> template<typename _RandomAccessIterator, typename _Distance>
> inline void
> __advance(_RandomAccessIterator& __i, _Distance __n,
> random_access_iterator_tag)
> {
>
> 
>
> __i += __n;
> }
># 170 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator, typename _Distance>
> inline void
> advance(_InputIterator& __i, _Distance __n)
> {
>
> std::__advance(__i, __n, std::__iterator_category(__i));
> }
>}
># 74 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 1 3
># 70 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
>namespace std
>{
># 91 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class reverse_iterator
> : public iterator<typename iterator_traits<_Iterator>::iterator_category,
> typename iterator_traits<_Iterator>::value_type,
> typename iterator_traits<_Iterator>::difference_type,
> typename iterator_traits<_Iterator>::pointer,
> typename iterator_traits<_Iterator>::reference>
> {
> protected:
> _Iterator current;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename iterator_traits<_Iterator>::difference_type
> difference_type;
> typedef typename iterator_traits<_Iterator>::reference reference;
> typedef typename iterator_traits<_Iterator>::pointer pointer;
>
> public:
>
>
>
>
>
>
> reverse_iterator() : current() { }
>
>
>
>
> explicit
> reverse_iterator(iterator_type __x) : current(__x) { }
>
>
>
>
> reverse_iterator(const reverse_iterator& __x)
> : current(__x.current) { }
>
>
>
>
>
> template<typename _Iter>
> reverse_iterator(const reverse_iterator<_Iter>& __x)
> : current(__x.base()) { }
>
>
>
>
> iterator_type
> base() const
> { return current; }
>
>
>
>
>
>
> reference
> operator*() const
> {
> _Iterator __tmp = current;
> return *--__tmp;
> }
>
>
>
>
>
>
> pointer
> operator->() const
> { return &(operator*()); }
>
>
>
>
>
>
> reverse_iterator&
> operator++()
> {
> --current;
> return *this;
> }
>
>
>
>
>
>
> reverse_iterator
> operator++(int)
> {
> reverse_iterator __tmp = *this;
> --current;
> return __tmp;
> }
>
>
>
>
>
>
> reverse_iterator&
> operator--()
> {
> ++current;
> return *this;
> }
>
>
>
>
>
>
> reverse_iterator
> operator--(int)
> {
> reverse_iterator __tmp = *this;
> ++current;
> return __tmp;
> }
>
>
>
>
>
>
> reverse_iterator
> operator+(difference_type __n) const
> { return reverse_iterator(current - __n); }
>
>
>
>
>
>
> reverse_iterator&
> operator+=(difference_type __n)
> {
> current -= __n;
> return *this;
> }
>
>
>
>
>
>
> reverse_iterator
> operator-(difference_type __n) const
> { return reverse_iterator(current + __n); }
>
>
>
>
>
>
> reverse_iterator&
> operator-=(difference_type __n)
> {
> current += __n;
> return *this;
> }
>
>
>
>
>
>
> reference
> operator[](difference_type __n) const
> { return *(*this + __n); }
> };
># 278 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Iterator>
> inline bool
> operator==(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator<(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _Iterator>
> inline bool
> operator!=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline bool
> operator>(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline bool
> operator<=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline bool
> operator>=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
> template<typename _Iterator>
> inline typename reverse_iterator<_Iterator>::difference_type
> operator-(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() - __x.base(); }
>
> template<typename _Iterator>
> inline reverse_iterator<_Iterator>
> operator+(typename reverse_iterator<_Iterator>::difference_type __n,
> const reverse_iterator<_Iterator>& __x)
> { return reverse_iterator<_Iterator>(__x.base() - __n); }
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator==(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator!=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline typename reverse_iterator<_IteratorL>::difference_type
> operator-(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y.base() - __x.base(); }
># 382 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Container>
> class back_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit
> back_insert_iterator(_Container& __x) : container(&__x) { }
># 408 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> back_insert_iterator&
> operator=(typename _Container::const_reference __value)
> {
> container->push_back(__value);
> return *this;
> }
>
>
> back_insert_iterator&
> operator*()
> { return *this; }
>
>
> back_insert_iterator&
> operator++()
> { return *this; }
>
>
> back_insert_iterator
> operator++(int)
> { return *this; }
> };
># 442 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Container>
> inline back_insert_iterator<_Container>
> back_inserter(_Container& __x)
> { return back_insert_iterator<_Container>(__x); }
># 457 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Container>
> class front_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit front_insert_iterator(_Container& __x) : container(&__x) { }
># 482 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> front_insert_iterator&
> operator=(typename _Container::const_reference __value)
> {
> container->push_front(__value);
> return *this;
> }
>
>
> front_insert_iterator&
> operator*()
> { return *this; }
>
>
> front_insert_iterator&
> operator++()
> { return *this; }
>
>
> front_insert_iterator
> operator++(int)
> { return *this; }
> };
># 516 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Container>
> inline front_insert_iterator<_Container>
> front_inserter(_Container& __x)
> { return front_insert_iterator<_Container>(__x); }
># 535 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Container>
> class insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
> typename _Container::iterator iter;
>
> public:
>
> typedef _Container container_type;
>
>
>
>
>
> insert_iterator(_Container& __x, typename _Container::iterator __i)
> : container(&__x), iter(__i) {}
># 577 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> insert_iterator&
> operator=(const typename _Container::const_reference __value)
> {
> iter = container->insert(iter, __value);
> ++iter;
> return *this;
> }
>
>
> insert_iterator&
> operator*()
> { return *this; }
>
>
> insert_iterator&
> operator++()
> { return *this; }
>
>
> insert_iterator&
> operator++(int)
> { return *this; }
> };
># 612 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _Container, typename _Iterator>
> inline insert_iterator<_Container>
> inserter(_Container& __x, _Iterator __i)
> {
> return insert_iterator<_Container>(__x,
> typename _Container::iterator(__i));
> }
>}
>
>namespace __gnu_cxx
>{
>
>
>
>
>
>
>
> using std::iterator_traits;
> using std::iterator;
> template<typename _Iterator, typename _Container>
> class __normal_iterator
> {
> protected:
> _Iterator _M_current;
>
> public:
> typedef typename iterator_traits<_Iterator>::iterator_category
> iterator_category;
> typedef typename iterator_traits<_Iterator>::value_type value_type;
> typedef typename iterator_traits<_Iterator>::difference_type
> difference_type;
> typedef typename iterator_traits<_Iterator>::reference reference;
> typedef typename iterator_traits<_Iterator>::pointer pointer;
>
> __normal_iterator() : _M_current(_Iterator()) { }
>
> explicit
> __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
>
>
> template<typename _Iter>
> __normal_iterator(const __normal_iterator<_Iter,
> typename std::__enable_if<_Container,
> (std::__are_same<_Iter,
> typename _Container::pointer>::__value)
> >::__type>& __i)
> : _M_current(__i.base()) { }
>
>
> reference
> operator*() const
> { return *_M_current; }
>
> pointer
> operator->() const
> { return _M_current; }
>
> __normal_iterator&
> operator++()
> {
> ++_M_current;
> return *this;
> }
>
> __normal_iterator
> operator++(int)
> { return __normal_iterator(_M_current++); }
>
>
> __normal_iterator&
> operator--()
> {
> --_M_current;
> return *this;
> }
>
> __normal_iterator
> operator--(int)
> { return __normal_iterator(_M_current--); }
>
>
> reference
> operator[](const difference_type& __n) const
> { return _M_current[__n]; }
>
> __normal_iterator&
> operator+=(const difference_type& __n)
> { _M_current += __n; return *this; }
>
> __normal_iterator
> operator+(const difference_type& __n) const
> { return __normal_iterator(_M_current + __n); }
>
> __normal_iterator&
> operator-=(const difference_type& __n)
> { _M_current -= __n; return *this; }
>
> __normal_iterator
> operator-(const difference_type& __n) const
> { return __normal_iterator(_M_current - __n); }
>
> const _Iterator&
> base() const
> { return _M_current; }
> };
># 728 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_iterator.h" 3
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() != __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() != __rhs.base(); }
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() >= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() >= __rhs.base(); }
>
>
>
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline typename __normal_iterator<_IteratorL, _Container>::difference_type
> operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline __normal_iterator<_Iterator, _Container>
> operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
> __n, const __normal_iterator<_Iterator, _Container>& __i)
> { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
>}
># 75 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/debug/debug.h" 1 3
># 77 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 2 3
>
>namespace std
>{
># 90 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline void
> swap(_Tp& __a, _Tp& __b)
> {
>
> 
>
> _Tp __tmp = __a;
> __a = __b;
> __b = __tmp;
> }
>
>
>
>
> template<bool _BoolType>
> struct __iter_swap
> {
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> static void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
> typedef typename iterator_traits<_ForwardIterator1>::value_type
> _ValueType1;
> _ValueType1 __tmp = *__a;
> *__a = *__b;
> *__b = __tmp;
> }
> };
>
> template<>
> struct __iter_swap<true>
> {
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> static void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
> swap(*__a, *__b);
> }
> };
># 140 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
> typedef typename iterator_traits<_ForwardIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_ForwardIterator2>::value_type
> _ValueType2;
>
>
> 
>
> 
>
> 
>
> 
>
>
> typedef typename iterator_traits<_ForwardIterator1>::reference
> _ReferenceType1;
> typedef typename iterator_traits<_ForwardIterator2>::reference
> _ReferenceType2;
> std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value &&
> __are_same<_ValueType1 &, _ReferenceType1>::__value &&
> __are_same<_ValueType2 &, _ReferenceType2>::__value>::
> iter_swap(__a, __b);
> }
># 182 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__b < __a)
> return __b;
> return __a;
> }
># 204 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__a < __b)
> return __b;
> return __a;
> }
># 226 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__b, __a))
> return __b;
> return __a;
> }
># 246 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__a, __b))
> return __b;
> return __a;
> }
>
>
>
>
>
>
>
> template<bool, typename>
> struct __copy
> {
> template<typename _II, typename _OI>
> static _OI
> copy(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, ++__first)
> *__result = *__first;
> return __result;
> }
> };
>
> template<bool _BoolType>
> struct __copy<_BoolType, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> copy(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = *__first;
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
> template<>
> struct __copy<true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> std::memmove(__result, __first, sizeof(_Tp) * (__last - __first));
> return __result + (__last - __first);
> }
> };
>
> template<typename _II, typename _OI>
> inline _OI
> __copy_aux(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::value_type _ValueTypeI;
> typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
> typedef typename iterator_traits<_II>::iterator_category _Category;
> const bool __simple = (__is_scalar<_ValueTypeI>::__value
> && __is_pointer<_II>::__value
> && __is_pointer<_OI>::__value
> && __are_same<_ValueTypeI, _ValueTypeO>::__value);
>
> return std::__copy<__simple, _Category>::copy(__first, __last, __result);
> }
>
> template<bool, bool>
> struct __copy_normal
> {
> template<typename _II, typename _OI>
> static _OI
> copy_n(_II __first, _II __last, _OI __result)
> { return std::__copy_aux(__first, __last, __result); }
> };
>
> template<>
> struct __copy_normal<true, false>
> {
> template<typename _II, typename _OI>
> static _OI
> copy_n(_II __first, _II __last, _OI __result)
> { return std::__copy_aux(__first.base(), __last.base(), __result); }
> };
>
> template<>
> struct __copy_normal<false, true>
> {
> template<typename _II, typename _OI>
> static _OI
> copy_n(_II __first, _II __last, _OI __result)
> { return _OI(std::__copy_aux(__first, __last, __result.base())); }
> };
>
> template<>
> struct __copy_normal<true, true>
> {
> template<typename _II, typename _OI>
> static _OI
> copy_n(_II __first, _II __last, _OI __result)
> { return _OI(std::__copy_aux(__first.base(), __last.base(),
> __result.base())); }
> };
># 373 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> ;
>
> const bool __in = __is_normal_iterator<_InputIterator>::__value;
> const bool __out = __is_normal_iterator<_OutputIterator>::__value;
> return std::__copy_normal<__in, __out>::copy_n(__first, __last,
> __result);
> }
>
> template<bool, typename>
> struct __copy_backward
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> copy_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = *--__last;
> return __result;
> }
> };
>
> template<bool _BoolType>
> struct __copy_backward<_BoolType, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> copy_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = *--__last;
> return __result;
> }
> };
>
> template<>
> struct __copy_backward<true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> copy_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> const ptrdiff_t _Num = __last - __first;
> std::memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
> return __result - _Num;
> }
> };
>
> template<typename _BI1, typename _BI2>
> inline _BI2
> __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typedef typename iterator_traits<_BI1>::value_type _ValueType1;
> typedef typename iterator_traits<_BI2>::value_type _ValueType2;
> typedef typename iterator_traits<_BI1>::iterator_category _Category;
> const bool __simple = (__is_scalar<_ValueType1>::__value
> && __is_pointer<_BI1>::__value
> && __is_pointer<_BI2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__copy_backward<__simple, _Category>::copy_b(__first, __last,
> __result);
> }
>
> template<bool, bool>
> struct __copy_backward_normal
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
> { return std::__copy_backward_aux(__first, __last, __result); }
> };
>
> template<>
> struct __copy_backward_normal<true, false>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
> { return std::__copy_backward_aux(__first.base(), __last.base(),
> __result); }
> };
>
> template<>
> struct __copy_backward_normal<false, true>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
> { return _BI2(std::__copy_backward_aux(__first, __last,
> __result.base())); }
> };
>
> template<>
> struct __copy_backward_normal<true, true>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
> { return _BI2(std::__copy_backward_aux(__first.base(), __last.base(),
> __result.base())); }
> };
># 502 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template <typename _BI1, typename _BI2>
> inline _BI2
> copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> const bool __bi1 = __is_normal_iterator<_BI1>::__value;
> const bool __bi2 = __is_normal_iterator<_BI2>::__value;
> return std::__copy_backward_normal<__bi1, __bi2>::copy_b_n(__first, __last,
> __result);
> }
>
> template<bool>
> struct __fill
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> for (; __first != __last; ++__first)
> *__first = __value;
> }
> };
>
> template<>
> struct __fill<true>
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (; __first != __last; ++__first)
> *__first = __tmp;
> }
> };
># 558 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
> {
>
> 
>
> ;
>
> const bool __scalar = __is_scalar<_Tp>::__value;
> std::__fill<__scalar>::fill(__first, __last, __value);
> }
>
>
> inline void
> fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
> {
> ;
> const unsigned char __tmp = __c;
> std::memset(__first, __tmp, __last - __first);
> }
>
> inline void
> fill(signed char* __first, signed char* __last, const signed char& __c)
> {
> ;
> const signed char __tmp = __c;
> std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
> }
>
> inline void
> fill(char* __first, char* __last, const char& __c)
> {
> ;
> const char __tmp = __c;
> std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
> }
>
> template<bool>
> struct __fill_n
> {
> template<typename _OutputIterator, typename _Size, typename _Tp>
> static _OutputIterator
> fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> for (; __n > 0; --__n, ++__first)
> *__first = __value;
> return __first;
> }
> };
>
> template<>
> struct __fill_n<true>
> {
> template<typename _OutputIterator, typename _Size, typename _Tp>
> static _OutputIterator
> fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (; __n > 0; --__n, ++__first)
> *__first = __tmp;
> return __first;
> }
> };
># 634 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _OutputIterator, typename _Size, typename _Tp>
> _OutputIterator
> fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
>
> 
>
> const bool __scalar = __is_scalar<_Tp>::__value;
> return std::__fill_n<__scalar>::fill_n(__first, __n, __value);
> }
>
> template<typename _Size>
> inline unsigned char*
> fill_n(unsigned char* __first, _Size __n, const unsigned char& __c)
> {
> std::fill(__first, __first + __n, __c);
> return __first + __n;
> }
>
> template<typename _Size>
> inline signed char*
> fill_n(char* __first, _Size __n, const signed char& __c)
> {
> std::fill(__first, __first + __n, __c);
> return __first + __n;
> }
>
> template<typename _Size>
> inline char*
> fill_n(char* __first, _Size __n, const char& __c)
> {
> std::fill(__first, __first + __n, __c);
> return __first + __n;
> }
># 681 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> while (__first1 != __last1 && *__first1 == *__first2)
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 716 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> while (__first1 != __last1 && __binary_pred(*__first1, *__first2))
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 746 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> inline bool
> equal(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> return false;
> return true;
> }
># 778 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> inline bool
> equal(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!__binary_pred(*__first1, *__first2))
> return false;
> return true;
> }
># 810 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> bool
> lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
>
> 
> 
> 
>
>
> 
>
>
> ;
> ;
>
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, ++__first2)
> {
> if (*__first1 < *__first2)
> return true;
> if (*__first2 < *__first1)
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
># 850 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _Compare __comp)
> {
>
> 
> 
> ;
> ;
>
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, ++__first2)
> {
> if (__comp(*__first1, *__first2))
> return true;
> if (__comp(*__first2, *__first1))
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
>
> inline bool
> lexicographical_compare(const unsigned char* __first1,
> const unsigned char* __last1,
> const unsigned char* __first2,
> const unsigned char* __last2)
> {
> ;
> ;
>
> const size_t __len1 = __last1 - __first1;
> const size_t __len2 = __last2 - __first2;
> const int __result = std::memcmp(__first1, __first2,
> std::min(__len1, __len2));
> return __result != 0 ? __result < 0 : __len1 < __len2;
> }
>
> inline bool
> lexicographical_compare(const char* __first1, const char* __last1,
> const char* __first2, const char* __last2)
> {
> ;
> ;
>
>
> return std::lexicographical_compare((const signed char*) __first1,
> (const signed char*) __last1,
> (const signed char*) __first2,
> (const signed char*) __last2);
>
>
>
>
>
>
> }
>
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 2 3
>
>
>namespace __gnu_cxx
>{
># 61 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 3
> template <class _CharT>
> struct _Char_types
> {
> typedef unsigned long int_type;
> typedef std::streampos pos_type;
> typedef std::streamoff off_type;
> typedef std::mbstate_t state_type;
> };
># 86 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 3
> template<typename _CharT>
> struct char_traits
> {
> typedef _CharT char_type;
> typedef typename _Char_types<_CharT>::int_type int_type;
> typedef typename _Char_types<_CharT>::pos_type pos_type;
> typedef typename _Char_types<_CharT>::off_type off_type;
> typedef typename _Char_types<_CharT>::state_type state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2)
> { __c1 = __c2; }
>
> static bool
> eq(const char_type& __c1, const char_type& __c2)
> { return __c1 == __c2; }
>
> static bool
> lt(const char_type& __c1, const char_type& __c2)
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static std::size_t
> length(const char_type* __s);
>
> static const char_type*
> find(const char_type* __s, std::size_t __n, const char_type& __a);
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static char_type*
> assign(char_type* __s, std::size_t __n, char_type __a);
>
> static char_type
> to_char_type(const int_type& __c)
> { return static_cast<char_type>(__c); }
>
> static int_type
> to_int_type(const char_type& __c)
> { return static_cast<int_type>(__c); }
>
> static bool
> eq_int_type(const int_type& __c1, const int_type& __c2)
> { return __c1 == __c2; }
>
> static int_type
> eof()
> { return static_cast<int_type>((-1)); }
>
> static int_type
> not_eof(const int_type& __c)
> { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
> };
>
> template<typename _CharT>
> int
> char_traits<_CharT>::
> compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> template<typename _CharT>
> std::size_t
> char_traits<_CharT>::
> length(const char_type* __p)
> {
> std::size_t __i = 0;
> while (!eq(__p[__i], char_type()))
> ++__i;
> return __i;
> }
>
> template<typename _CharT>
> const typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> find(const char_type* __s, std::size_t __n, const char_type& __a)
> {
> for (std::size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> move(char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> return static_cast<_CharT*>(std::memmove(__s1, __s2,
> __n * sizeof(char_type)));
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> copy(char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> std::copy(__s2, __s2 + __n, __s1);
> return __s1;
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> assign(char_type* __s, std::size_t __n, char_type __a)
> {
> std::fill_n(__s, __n, __a);
> return __s;
> }
>}
>
>namespace std
>{
># 224 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/char_traits.h" 3
> template<class _CharT>
> struct char_traits : public __gnu_cxx::char_traits<_CharT>
> { };
>
>
>
> template<>
> struct char_traits<char>
> {
> typedef char char_type;
> typedef int int_type;
> typedef streampos pos_type;
> typedef streamoff off_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2)
> { __c1 = __c2; }
>
> static bool
> eq(const char_type& __c1, const char_type& __c2)
> { return __c1 == __c2; }
>
> static bool
> lt(const char_type& __c1, const char_type& __c2)
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> { return memcmp(__s1, __s2, __n); }
>
> static size_t
> length(const char_type* __s)
> { return strlen(__s); }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> { return static_cast<const char_type*>(memchr(__s, __a, __n)); }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> { return static_cast<char_type*>(memset(__s, __a, __n)); }
>
> static char_type
> to_char_type(const int_type& __c)
> { return static_cast<char_type>(__c); }
>
>
>
> static int_type
> to_int_type(const char_type& __c)
> { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
>
> static bool
> eq_int_type(const int_type& __c1, const int_type& __c2)
> { return __c1 == __c2; }
>
> static int_type
> eof() { return static_cast<int_type>((-1)); }
>
> static int_type
> not_eof(const int_type& __c)
> { return (__c == eof()) ? 0 : __c; }
> };
>
>
>
>
> template<>
> struct char_traits<wchar_t>
> {
> typedef wchar_t char_type;
> typedef wint_t int_type;
> typedef streamoff off_type;
> typedef wstreampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2)
> { __c1 = __c2; }
>
> static bool
> eq(const char_type& __c1, const char_type& __c2)
> { return __c1 == __c2; }
>
> static bool
> lt(const char_type& __c1, const char_type& __c2)
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> { return wmemcmp(__s1, __s2, __n); }
>
> static size_t
> length(const char_type* __s)
> { return wcslen(__s); }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> { return wmemchr(__s, __a, __n); }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> { return wmemmove(__s1, __s2, __n); }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> { return wmemcpy(__s1, __s2, __n); }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> { return wmemset(__s, __a, __n); }
>
> static char_type
> to_char_type(const int_type& __c) { return char_type(__c); }
>
> static int_type
> to_int_type(const char_type& __c) { return int_type(__c); }
>
> static bool
> eq_int_type(const int_type& __c1, const int_type& __c2)
> { return __c1 == __c2; }
>
> static int_type
> eof() { return static_cast<int_type>((0xffffffffu)); }
>
> static int_type
> not_eof(const int_type& __c)
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 1 3
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> 
># 52 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/allocator.h" 1 3
># 52 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/allocator.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++allocator.h" 1 3
># 34 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++allocator.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ext/new_allocator.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ext/new_allocator.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/new" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/new" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/exception" 1 3
># 40 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/exception" 3
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace std
>{
># 54 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/exception" 3
> class exception
> {
> public:
> exception() throw() { }
> virtual ~exception() throw();
>
>
> virtual const char* what() const throw();
> };
>
>
>
> class bad_exception : public exception
> {
> public:
> bad_exception() throw() { }
>
>
> virtual ~bad_exception() throw();
> };
>
>
> typedef void (*terminate_handler) ();
>
> typedef void (*unexpected_handler) ();
>
>
> terminate_handler set_terminate(terminate_handler) throw();
>
>
> void terminate() __attribute__ ((__noreturn__));
>
>
> unexpected_handler set_unexpected(unexpected_handler) throw();
>
>
> void unexpected() __attribute__ ((__noreturn__));
># 102 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/exception" 3
> bool uncaught_exception() throw();
>}
>
>namespace __gnu_cxx
>{
># 117 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/exception" 3
> void __verbose_terminate_handler ();
>}
>
>}
>
>#pragma GCC visibility pop
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/new" 2 3
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
> class bad_alloc : public exception
> {
> public:
> bad_alloc() throw() { }
>
>
> virtual ~bad_alloc() throw();
> };
>
> struct nothrow_t { };
> extern const nothrow_t nothrow;
>
>
> typedef void (*new_handler)();
>
> new_handler set_new_handler(new_handler) throw();
>}
># 84 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/new" 3
>void* operator new(std::size_t) throw (std::bad_alloc);
>void* operator new[](std::size_t) throw (std::bad_alloc);
>void operator delete(void*) throw();
>void operator delete[](void*) throw();
>void* operator new(std::size_t, const std::nothrow_t&) throw();
>void* operator new[](std::size_t, const std::nothrow_t&) throw();
>void operator delete(void*, const std::nothrow_t&) throw();
>void operator delete[](void*, const std::nothrow_t&) throw();
>
>
>inline void* operator new(std::size_t, void* __p) throw() { return __p; }
>inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
>
>
>inline void operator delete (void*, void*) throw() { }
>inline void operator delete[](void*, void*) throw() { }
>
>}
>
>#pragma GCC visibility pop
># 38 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ext/new_allocator.h" 2 3
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
>
>
> template<typename _Tp>
> class new_allocator
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef new_allocator<_Tp1> other; };
>
> new_allocator() throw() { }
>
> new_allocator(const new_allocator&) throw() { }
>
> template<typename _Tp1>
> new_allocator(const new_allocator<_Tp1>&) throw() { }
>
> ~new_allocator() throw() { }
>
> pointer
> address(reference __x) const { return &__x; }
>
> const_pointer
> address(const_reference __x) const { return &__x; }
>
>
>
> pointer
> allocate(size_type __n, const void* = 0)
> {
> if (__builtin_expect(__n > this->max_size(), false))
> std::__throw_bad_alloc();
>
> return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
> }
>
>
> void
> deallocate(pointer __p, size_type)
> { ::operator delete(__p); }
>
> size_type
> max_size() const throw()
> { return size_t(-1) / sizeof(_Tp); }
>
>
>
> void
> construct(pointer __p, const _Tp& __val)
> { ::new(__p) _Tp(__val); }
>
> void
> destroy(pointer __p) { __p->~_Tp(); }
> };
>
> template<typename _Tp>
> inline bool
> operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return false; }
>}
># 35 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/c++allocator.h" 2 3
># 53 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/allocator.h" 2 3
>
>namespace std
>{
> template<typename _Tp>
> class allocator;
>
>
> template<>
> class allocator<void>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef void* pointer;
> typedef const void* const_pointer;
> typedef void value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
> };
>
>
>
>
>
>
>
> template<typename _Tp>
> class allocator: public __gnu_cxx::new_allocator<_Tp>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
>
> allocator() throw() { }
>
> allocator(const allocator& __a) throw()
> : __gnu_cxx::new_allocator<_Tp>(__a) { }
>
> template<typename _Tp1>
> allocator(const allocator<_Tp1>&) throw() { }
>
> ~allocator() throw() { }
>
>
> };
>
> template<typename _T1, typename _T2>
> inline bool
> operator==(const allocator<_T1>&, const allocator<_T2>&)
> { return true; }
>
> template<typename _T1, typename _T2>
> inline bool
> operator!=(const allocator<_T1>&, const allocator<_T2>&)
> { return false; }
>
>
>
>
>
> extern template class allocator<char>;
> extern template class allocator<wchar_t>;
>
>
>
>
>}
># 55 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_construct.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_construct.h" 3
>namespace std
>{
>
>
>
>
>
>
> template<typename _T1, typename _T2>
> inline void
> _Construct(_T1* __p, const _T2& __value)
> {
>
>
> ::new(static_cast<void*>(__p)) _T1(__value);
> }
>
>
>
>
>
>
>
> template<typename _T1>
> inline void
> _Construct(_T1* __p)
> {
>
>
> ::new(static_cast<void*>(__p)) _T1();
> }
>
>
>
>
>
>
> template<typename _Tp>
> inline void
> _Destroy(_Tp* __pointer)
> { __pointer->~_Tp(); }
># 116 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_construct.h" 3
> template<typename _ForwardIterator>
> inline void
> __destroy_aux(_ForwardIterator __first, _ForwardIterator __last,
> __false_type)
> {
> for (; __first != __last; ++__first)
> std::_Destroy(&*__first);
> }
># 134 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_construct.h" 3
> template<typename _ForwardIterator>
> inline void
> __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type)
> { }
># 146 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_construct.h" 3
> template<typename _ForwardIterator>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _Value_type;
> typedef typename std::__is_scalar<_Value_type>::__type
> _Has_trivial_destructor;
>
> std::__destroy_aux(__first, __last, _Has_trivial_destructor());
> }
># 166 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_construct.h" 3
> template <typename _Tp> class allocator;
>
> template<typename _ForwardIterator, typename _Allocator>
> void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> _Allocator __alloc)
> {
> for (; __first != __last; ++__first)
> __alloc.destroy(&*__first);
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> allocator<_Tp>)
> {
> _Destroy(__first, __last);
> }
>
>
>}
># 56 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_uninitialized.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_uninitialized.h" 3
>namespace std
>{
>
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> __true_type)
> { return std::copy(__first, __last, __result); }
>
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> __false_type)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __first != __last; ++__first, ++__cur)
> std::_Construct(&*__cur, *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
># 105 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
> typedef typename std::__is_scalar<_ValueType>::__type _Is_POD;
> return std::__uninitialized_copy_aux(__first, __last, __result,
> _Is_POD());
> }
>
> inline char*
> uninitialized_copy(const char* __first, const char* __last, char* __result)
> {
> std::memmove(__result, __first, __last - __first);
> return __result + (__last - __first);
> }
>
> inline wchar_t*
> uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
> wchar_t* __result)
> {
> std::memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
> return __result + (__last - __first);
> }
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_fill_aux(_ForwardIterator __first,
> _ForwardIterator __last,
> const _Tp& __x, __true_type)
> { std::fill(__first, __last, __x); }
>
> template<typename _ForwardIterator, typename _Tp>
> void
> __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, __false_type)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(&*__cur, __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
># 167 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
> typedef typename std::__is_scalar<_ValueType>::__type _Is_POD;
> std::__uninitialized_fill_aux(__first, __last, __x, _Is_POD());
> }
>
>
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline void
> __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
> const _Tp& __x, __true_type)
> { std::fill_n(__first, __n, __x); }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> void
> __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
> const _Tp& __x, __false_type)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, ++__cur)
> std::_Construct(&*__cur, __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
># 212 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline void
> uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
> typedef typename std::__is_scalar<_ValueType>::__type _Is_POD;
> std::__uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> _Allocator __alloc)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __first != __last; ++__first, ++__cur)
> __alloc.construct(&*__cur, *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> allocator<_Tp>)
> {
> return std::uninitialized_copy(__first, __last, __result);
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Allocator>
> void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, _Allocator __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> __alloc.construct(&*__cur, __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Tp2>
> inline void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, allocator<_Tp2>)
> {
> std::uninitialized_fill(__first, __last, __x);
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Allocator>
> void
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x,
> _Allocator __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, ++__cur)
> __alloc.construct(&*__cur, __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Tp2>
> void
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x,
> allocator<_Tp2>)
> {
> std::uninitialized_fill_n(__first, __n, __x);
> }
># 323 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_uninitialized.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_copy_copy(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
> const _Tp& __x, _InputIterator __first,
> _InputIterator __last,
> _Allocator __alloc)
> {
> std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
> try
> {
> return std::__uninitialized_copy_a(__first, __last, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
> typename _Allocator>
> inline void
> __uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2,
> _ForwardIterator __last2, const _Tp& __x,
> _Allocator __alloc)
> {
> _ForwardIterator __mid2 = std::__uninitialized_copy_a(__first1, __last1,
> __first2,
> __alloc);
> try
> {
> std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__first2, __mid2, __alloc);
> throw;
> }
> }
>
>}
># 58 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_raw_storage_iter.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_raw_storage_iter.h" 3
>namespace std
>{
>
>
>
>
> template <class _ForwardIterator, class _Tp>
> class raw_storage_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _ForwardIterator _M_iter;
>
> public:
> explicit
> raw_storage_iterator(_ForwardIterator __x)
> : _M_iter(__x) {}
>
> raw_storage_iterator&
> operator*() { return *this; }
>
> raw_storage_iterator&
> operator=(const _Tp& __element)
> {
> std::_Construct(&*_M_iter, __element);
> return *this;
> }
>
> raw_storage_iterator<_ForwardIterator, _Tp>&
> operator++()
> {
> ++_M_iter;
> return *this;
> }
>
> raw_storage_iterator<_ForwardIterator, _Tp>
> operator++(int)
> {
> raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
> ++_M_iter;
> return __tmp;
> }
> };
>}
># 59 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/limits" 1 3
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/limits" 3
> 
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/limits" 3
># 149 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/limits" 3
>namespace std
>{
>
>
>
>
>
> enum float_round_style
> {
> round_indeterminate = -1,
> round_toward_zero = 0,
> round_to_nearest = 1,
> round_toward_infinity = 2,
> round_toward_neg_infinity = 3
> };
>
>
>
>
>
>
>
> enum float_denorm_style
> {
>
> denorm_indeterminate = -1,
>
> denorm_absent = 0,
>
> denorm_present = 1
> };
># 191 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/limits" 3
> struct __numeric_limits_base
> {
>
>
> static const bool is_specialized = false;
>
>
>
>
> static const int digits = 0;
>
> static const int digits10 = 0;
>
> static const bool is_signed = false;
>
>
>
>
>
> static const bool is_integer = false;
>
>
>
>
> static const bool is_exact = false;
>
>
> static const int radix = 0;
>
>
>
> static const int min_exponent = 0;
>
>
> static const int min_exponent10 = 0;
>
>
>
> static const int max_exponent = 0;
>
>
> static const int max_exponent10 = 0;
>
>
> static const bool has_infinity = false;
>
>
> static const bool has_quiet_NaN = false;
>
>
> static const bool has_signaling_NaN = false;
>
> static const float_denorm_style has_denorm = denorm_absent;
>
>
> static const bool has_denorm_loss = false;
>
>
>
> static const bool is_iec559 = false;
>
>
>
> static const bool is_bounded = false;
>
>
>
>
> static const bool is_modulo = false;
>
>
> static const bool traps = false;
>
> static const bool tinyness_before = false;
>
>
>
> static const float_round_style round_style = round_toward_zero;
> };
># 284 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/limits" 3
> template<typename _Tp>
> struct numeric_limits : public __numeric_limits_base
> {
>
>
> static _Tp min() throw() { return static_cast<_Tp>(0); }
>
> static _Tp max() throw() { return static_cast<_Tp>(0); }
>
>
> static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
>
> static _Tp round_error() throw() { return static_cast<_Tp>(0); }
>
> static _Tp infinity() throw() { return static_cast<_Tp>(0); }
>
> static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
>
>
> static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
>
>
>
> static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
> };
>
>
>
>
>
> template<>
> struct numeric_limits<bool>
> {
> static const bool is_specialized = true;
>
> static bool min() throw()
> { return false; }
> static bool max() throw()
> { return true; }
>
> static const int digits = 1;
> static const int digits10 = 0;
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static bool epsilon() throw()
> { return false; }
> static bool round_error() throw()
> { return false; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static bool infinity() throw()
> { return false; }
> static bool quiet_NaN() throw()
> { return false; }
> static bool signaling_NaN() throw()
> { return false; }
> static bool denorm_min() throw()
> { return false; }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
>
>
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char>
> {
> static const bool is_specialized = true;
>
> static char min() throw()
> { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
> static char max() throw()
> { return (((char)(-1) < 0) ? ((char)1 << (sizeof(char) * 8 - ((char)(-1) < 0))) - 1 : ~(char)0); }
>
> static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
> static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = ((char)(-1) < 0);
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static char epsilon() throw()
> { return 0; }
> static char round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static char infinity() throw()
> { return char(); }
> static char quiet_NaN() throw()
> { return char(); }
> static char signaling_NaN() throw()
> { return char(); }
> static char denorm_min() throw()
> { return static_cast<char>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<signed char>
> {
> static const bool is_specialized = true;
>
> static signed char min() throw()
> { return -127 - 1; }
> static signed char max() throw()
> { return 127; }
>
> static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
> static const int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static signed char epsilon() throw()
> { return 0; }
> static signed char round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static signed char infinity() throw()
> { return static_cast<signed char>(0); }
> static signed char quiet_NaN() throw()
> { return static_cast<signed char>(0); }
> static signed char signaling_NaN() throw()
> { return static_cast<signed char>(0); }
> static signed char denorm_min() throw()
> { return static_cast<signed char>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned char>
> {
> static const bool is_specialized = true;
>
> static unsigned char min() throw()
> { return 0; }
> static unsigned char max() throw()
> { return 127 * 2U + 1; }
>
> static const int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned char epsilon() throw()
> { return 0; }
> static unsigned char round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned char infinity() throw()
> { return static_cast<unsigned char>(0); }
> static unsigned char quiet_NaN() throw()
> { return static_cast<unsigned char>(0); }
> static unsigned char signaling_NaN() throw()
> { return static_cast<unsigned char>(0); }
> static unsigned char denorm_min() throw()
> { return static_cast<unsigned char>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<wchar_t>
> {
> static const bool is_specialized = true;
>
> static wchar_t min() throw()
> { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
> static wchar_t max() throw()
> { return (((wchar_t)(-1) < 0) ? ((wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0))) - 1 : ~(wchar_t)0); }
>
> static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
> static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = ((wchar_t)(-1) < 0);
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static wchar_t epsilon() throw()
> { return 0; }
> static wchar_t round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static wchar_t infinity() throw()
> { return wchar_t(); }
> static wchar_t quiet_NaN() throw()
> { return wchar_t(); }
> static wchar_t signaling_NaN() throw()
> { return wchar_t(); }
> static wchar_t denorm_min() throw()
> { return wchar_t(); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<short>
> {
> static const bool is_specialized = true;
>
> static short min() throw()
> { return -32767 - 1; }
> static short max() throw()
> { return 32767; }
>
> static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
> static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static short epsilon() throw()
> { return 0; }
> static short round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static short infinity() throw()
> { return short(); }
> static short quiet_NaN() throw()
> { return short(); }
> static short signaling_NaN() throw()
> { return short(); }
> static short denorm_min() throw()
> { return short(); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned short>
> {
> static const bool is_specialized = true;
>
> static unsigned short min() throw()
> { return 0; }
> static unsigned short max() throw()
> { return 32767 * 2U + 1; }
>
> static const int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned short epsilon() throw()
> { return 0; }
> static unsigned short round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned short infinity() throw()
> { return static_cast<unsigned short>(0); }
> static unsigned short quiet_NaN() throw()
> { return static_cast<unsigned short>(0); }
> static unsigned short signaling_NaN() throw()
> { return static_cast<unsigned short>(0); }
> static unsigned short denorm_min() throw()
> { return static_cast<unsigned short>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<int>
> {
> static const bool is_specialized = true;
>
> static int min() throw()
> { return -2147483647 - 1; }
> static int max() throw()
> { return 2147483647; }
>
> static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
> static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static int epsilon() throw()
> { return 0; }
> static int round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static int infinity() throw()
> { return static_cast<int>(0); }
> static int quiet_NaN() throw()
> { return static_cast<int>(0); }
> static int signaling_NaN() throw()
> { return static_cast<int>(0); }
> static int denorm_min() throw()
> { return static_cast<int>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned int>
> {
> static const bool is_specialized = true;
>
> static unsigned int min() throw()
> { return 0; }
> static unsigned int max() throw()
> { return 2147483647 * 2U + 1; }
>
> static const int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned int epsilon() throw()
> { return 0; }
> static unsigned int round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned int infinity() throw()
> { return static_cast<unsigned int>(0); }
> static unsigned int quiet_NaN() throw()
> { return static_cast<unsigned int>(0); }
> static unsigned int signaling_NaN() throw()
> { return static_cast<unsigned int>(0); }
> static unsigned int denorm_min() throw()
> { return static_cast<unsigned int>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long>
> {
> static const bool is_specialized = true;
>
> static long min() throw()
> { return -2147483647L - 1; }
> static long max() throw()
> { return 2147483647L; }
>
> static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
> static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static long epsilon() throw()
> { return 0; }
> static long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static long infinity() throw()
> { return static_cast<long>(0); }
> static long quiet_NaN() throw()
> { return static_cast<long>(0); }
> static long signaling_NaN() throw()
> { return static_cast<long>(0); }
> static long denorm_min() throw()
> { return static_cast<long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long>
> {
> static const bool is_specialized = true;
>
> static unsigned long min() throw()
> { return 0; }
> static unsigned long max() throw()
> { return 2147483647L * 2UL + 1; }
>
> static const int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned long epsilon() throw()
> { return 0; }
> static unsigned long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned long infinity() throw()
> { return static_cast<unsigned long>(0); }
> static unsigned long quiet_NaN() throw()
> { return static_cast<unsigned long>(0); }
> static unsigned long signaling_NaN() throw()
> { return static_cast<unsigned long>(0); }
> static unsigned long denorm_min() throw()
> { return static_cast<unsigned long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long long>
> {
> static const bool is_specialized = true;
>
> static long long min() throw()
> { return -9223372036854775807LL - 1; }
> static long long max() throw()
> { return 9223372036854775807LL; }
>
> static const int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0));
> static const int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static long long epsilon() throw()
> { return 0; }
> static long long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static long long infinity() throw()
> { return static_cast<long long>(0); }
> static long long quiet_NaN() throw()
> { return static_cast<long long>(0); }
> static long long signaling_NaN() throw()
> { return static_cast<long long>(0); }
> static long long denorm_min() throw()
> { return static_cast<long long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long long>
> {
> static const bool is_specialized = true;
>
> static unsigned long long min() throw()
> { return 0; }
> static unsigned long long max() throw()
> { return 9223372036854775807LL * 2ULL + 1; }
>
> static const int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned long long epsilon() throw()
> { return 0; }
> static unsigned long long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned long long infinity() throw()
> { return static_cast<unsigned long long>(0); }
> static unsigned long long quiet_NaN() throw()
> { return static_cast<unsigned long long>(0); }
> static unsigned long long signaling_NaN() throw()
> { return static_cast<unsigned long long>(0); }
> static unsigned long long denorm_min() throw()
> { return static_cast<unsigned long long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<float>
> {
> static const bool is_specialized = true;
>
> static float min() throw()
> { return 1.17549435e-38F; }
> static float max() throw()
> { return 3.40282347e+38F; }
>
> static const int digits = 24;
> static const int digits10 = 6;
> static const bool is_signed = true;
> static const bool is_integer = false;
> static const bool is_exact = false;
> static const int radix = 2;
> static float epsilon() throw()
> { return 1.19209290e-7F; }
> static float round_error() throw()
> { return 0.5F; }
>
> static const int min_exponent = (-125);
> static const int min_exponent10 = (-37);
> static const int max_exponent = 128;
> static const int max_exponent10 = 38;
>
> static const bool has_infinity = 1;
> static const bool has_quiet_NaN = 1;
> static const bool has_signaling_NaN = has_quiet_NaN;
> static const float_denorm_style has_denorm
> = bool(1.40129846e-45F) ? denorm_present : denorm_absent;
> static const bool has_denorm_loss = false;
>
> static float infinity() throw()
> { return __builtin_huge_valf (); }
> static float quiet_NaN() throw()
> { return __builtin_nanf (""); }
> static float signaling_NaN() throw()
> { return __builtin_nansf (""); }
> static float denorm_min() throw()
> { return 1.40129846e-45F; }
>
> static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
> static const bool traps = false;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<double>
> {
> static const bool is_specialized = true;
>
> static double min() throw()
> { return 2.2250738585072014e-308; }
> static double max() throw()
> { return 1.7976931348623157e+308; }
>
> static const int digits = 53;
> static const int digits10 = 15;
> static const bool is_signed = true;
> static const bool is_integer = false;
> static const bool is_exact = false;
> static const int radix = 2;
> static double epsilon() throw()
> { return 2.2204460492503131e-16; }
> static double round_error() throw()
> { return 0.5; }
>
> static const int min_exponent = (-1021);
> static const int min_exponent10 = (-307);
> static const int max_exponent = 1024;
> static const int max_exponent10 = 308;
>
> static const bool has_infinity = 1;
> static const bool has_quiet_NaN = 1;
> static const bool has_signaling_NaN = has_quiet_NaN;
> static const float_denorm_style has_denorm
> = bool(4.9406564584124654e-324) ? denorm_present : denorm_absent;
> static const bool has_denorm_loss = false;
>
> static double infinity() throw()
> { return __builtin_huge_val(); }
> static double quiet_NaN() throw()
> { return __builtin_nan (""); }
> static double signaling_NaN() throw()
> { return __builtin_nans (""); }
> static double denorm_min() throw()
> { return 4.9406564584124654e-324; }
>
> static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
> static const bool traps = false;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<long double>
> {
> static const bool is_specialized = true;
>
> static long double min() throw()
> { return 3.36210314311209350626e-4932L; }
> static long double max() throw()
> { return 1.18973149535723176502e+4932L; }
>
> static const int digits = 64;
> static const int digits10 = 18;
> static const bool is_signed = true;
> static const bool is_integer = false;
> static const bool is_exact = false;
> static const int radix = 2;
> static long double epsilon() throw()
> { return 1.08420217248550443401e-19L; }
> static long double round_error() throw()
> { return 0.5L; }
>
> static const int min_exponent = (-16381);
> static const int min_exponent10 = (-4931);
> static const int max_exponent = 16384;
> static const int max_exponent10 = 4932;
>
> static const bool has_infinity = 1;
> static const bool has_quiet_NaN = 1;
> static const bool has_signaling_NaN = has_quiet_NaN;
> static const float_denorm_style has_denorm
> = bool(3.64519953188247460253e-4951L) ? denorm_present : denorm_absent;
> static const bool has_denorm_loss
> = false;
>
> static long double infinity() throw()
> { return __builtin_huge_vall (); }
> static long double quiet_NaN() throw()
> { return __builtin_nanl (""); }
> static long double signaling_NaN() throw()
> { return __builtin_nansl (""); }
> static long double denorm_min() throw()
> { return 3.64519953188247460253e-4951L; }
>
> static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
> static const bool traps = false;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_to_nearest;
> };
>
>
>
>
>
>}
># 61 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 2 3
>
>namespace std
>{
># 72 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp>
> pair<_Tp*, ptrdiff_t>
> __get_temporary_buffer(ptrdiff_t __len, _Tp*)
> {
> const ptrdiff_t __max = numeric_limits<ptrdiff_t>::max() / sizeof(_Tp);
> if (__len > __max)
> __len = __max;
>
> while (__len > 0)
> {
> _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
> nothrow));
> if (__tmp != 0)
> return pair<_Tp*, ptrdiff_t>(__tmp, __len);
> __len /= 2;
> }
> return pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
> }
># 108 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp>
> inline pair<_Tp*, ptrdiff_t>
> get_temporary_buffer(ptrdiff_t __len)
> { return std::__get_temporary_buffer(__len, static_cast<_Tp*>(0)); }
># 120 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp>
> void
> return_temporary_buffer(_Tp* __p)
> { ::operator delete(__p, nothrow); }
># 132 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp1>
> struct auto_ptr_ref
> {
> _Tp1* _M_ptr;
>
> explicit
> auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
> };
># 173 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp>
> class auto_ptr
> {
> private:
> _Tp* _M_ptr;
>
> public:
>
> typedef _Tp element_type;
>
>
>
>
>
>
>
> explicit
> auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
># 199 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
># 211 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp1>
> auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
># 222 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> auto_ptr&
> operator=(auto_ptr& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 239 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> template<typename _Tp1>
> auto_ptr&
> operator=(auto_ptr<_Tp1>& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 259 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> ~auto_ptr() { delete _M_ptr; }
># 269 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> element_type&
> operator*() const throw()
> {
> ;
> return *_M_ptr;
> }
>
>
>
>
>
>
>
> element_type*
> operator->() const throw()
> {
> ;
> return _M_ptr;
> }
># 299 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> element_type*
> get() const throw() { return _M_ptr; }
># 313 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> element_type*
> release() throw()
> {
> element_type* __tmp = _M_ptr;
> _M_ptr = 0;
> return __tmp;
> }
># 328 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> void
> reset(element_type* __p = 0) throw()
> {
> if (__p != _M_ptr)
> {
> delete _M_ptr;
> _M_ptr = __p;
> }
> }
># 349 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/memory" 3
> auto_ptr(auto_ptr_ref<element_type> __ref) throw()
> : _M_ptr(__ref._M_ptr) { }
>
> auto_ptr&
> operator=(auto_ptr_ref<element_type> __ref) throw()
> {
> if (__ref._M_ptr != this->get())
> {
> delete _M_ptr;
> _M_ptr = __ref._M_ptr;
> }
> return *this;
> }
>
> template<typename _Tp1>
> operator auto_ptr_ref<_Tp1>() throw()
> { return auto_ptr_ref<_Tp1>(this->release()); }
>
> template<typename _Tp1>
> operator auto_ptr<_Tp1>() throw()
> { return auto_ptr<_Tp1>(this->release()); }
> };
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
>namespace std
>{
># 101 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Arg, class _Result>
> struct unary_function
> {
> typedef _Arg argument_type;
>
>
> typedef _Result result_type;
> };
>
>
>
>
> template <class _Arg1, class _Arg2, class _Result>
> struct binary_function
> {
> typedef _Arg1 first_argument_type;
>
>
> typedef _Arg2 second_argument_type;
> typedef _Result result_type;
> };
># 133 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Tp>
> struct plus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x + __y; }
> };
>
>
> template <class _Tp>
> struct minus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x - __y; }
> };
>
>
> template <class _Tp>
> struct multiplies : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x * __y; }
> };
>
>
> template <class _Tp>
> struct divides : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x / __y; }
> };
>
>
> template <class _Tp>
> struct modulus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x % __y; }
> };
>
>
> template <class _Tp>
> struct negate : public unary_function<_Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x) const
> { return -__x; }
> };
># 195 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Tp>
> struct equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x == __y; }
> };
>
>
> template <class _Tp>
> struct not_equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x != __y; }
> };
>
>
> template <class _Tp>
> struct greater : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x > __y; }
> };
>
>
> template <class _Tp>
> struct less : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x < __y; }
> };
>
>
> template <class _Tp>
> struct greater_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x >= __y; }
> };
>
>
> template <class _Tp>
> struct less_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x <= __y; }
> };
># 256 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Tp>
> struct logical_and : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x && __y; }
> };
>
>
> template <class _Tp>
> struct logical_or : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x || __y; }
> };
>
>
> template <class _Tp>
> struct logical_not : public unary_function<_Tp, bool>
> {
> bool
> operator()(const _Tp& __x) const
> { return !__x; }
> };
># 311 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Predicate>
> class unary_negate
> : public unary_function<typename _Predicate::argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
> public:
> explicit
> unary_negate(const _Predicate& __x) : _M_pred(__x) {}
>
> bool
> operator()(const typename _Predicate::argument_type& __x) const
> { return !_M_pred(__x); }
> };
>
>
> template <class _Predicate>
> inline unary_negate<_Predicate>
> not1(const _Predicate& __pred)
> { return unary_negate<_Predicate>(__pred); }
>
>
> template <class _Predicate>
> class binary_negate
> : public binary_function<typename _Predicate::first_argument_type,
> typename _Predicate::second_argument_type,
> bool>
> {
> protected:
> _Predicate _M_pred;
> public:
> explicit
> binary_negate(const _Predicate& __x)
> : _M_pred(__x) { }
>
> bool
> operator()(const typename _Predicate::first_argument_type& __x,
> const typename _Predicate::second_argument_type& __y) const
> { return !_M_pred(__x, __y); }
> };
>
>
> template <class _Predicate>
> inline binary_negate<_Predicate>
> not2(const _Predicate& __pred)
> { return binary_negate<_Predicate>(__pred); }
># 391 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Operation>
> class binder1st
> : public unary_function<typename _Operation::second_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::first_argument_type value;
> public:
> binder1st(const _Operation& __x,
> const typename _Operation::first_argument_type& __y)
> : op(__x), value(__y) {}
>
> typename _Operation::result_type
> operator()(const typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
> };
>
>
> template <class _Operation, class _Tp>
> inline binder1st<_Operation>
> bind1st(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::first_argument_type _Arg1_type;
> return binder1st<_Operation>(__fn, _Arg1_type(__x));
> }
>
>
> template <class _Operation>
> class binder2nd
> : public unary_function<typename _Operation::first_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::second_argument_type value;
> public:
> binder2nd(const _Operation& __x,
> const typename _Operation::second_argument_type& __y)
> : op(__x), value(__y) {}
>
> typename _Operation::result_type
> operator()(const typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
> };
>
>
> template <class _Operation, class _Tp>
> inline binder2nd<_Operation>
> bind2nd(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::second_argument_type _Arg2_type;
> return binder2nd<_Operation>(__fn, _Arg2_type(__x));
> }
># 480 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Arg, class _Result>
> class pointer_to_unary_function : public unary_function<_Arg, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg);
> public:
> pointer_to_unary_function() {}
>
> explicit
> pointer_to_unary_function(_Result (*__x)(_Arg))
> : _M_ptr(__x) {}
>
> _Result
> operator()(_Arg __x) const
> { return _M_ptr(__x); }
> };
>
>
> template <class _Arg, class _Result>
> inline pointer_to_unary_function<_Arg, _Result>
> ptr_fun(_Result (*__x)(_Arg))
> { return pointer_to_unary_function<_Arg, _Result>(__x); }
>
>
> template <class _Arg1, class _Arg2, class _Result>
> class pointer_to_binary_function
> : public binary_function<_Arg1, _Arg2, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg1, _Arg2);
> public:
> pointer_to_binary_function() {}
>
> explicit
> pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
> : _M_ptr(__x) {}
>
> _Result
> operator()(_Arg1 __x, _Arg2 __y) const
> { return _M_ptr(__x, __y); }
> };
>
>
> template <class _Arg1, class _Arg2, class _Result>
> inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
> ptr_fun(_Result (*__x)(_Arg1, _Arg2))
> { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
>
>
> template <class _Tp>
> struct _Identity : public unary_function<_Tp,_Tp>
> {
> _Tp&
> operator()(_Tp& __x) const
> { return __x; }
>
> const _Tp&
> operator()(const _Tp& __x) const
> { return __x; }
> };
>
> template <class _Pair>
> struct _Select1st : public unary_function<_Pair,
> typename _Pair::first_type>
> {
> typename _Pair::first_type&
> operator()(_Pair& __x) const
> { return __x.first; }
>
> const typename _Pair::first_type&
> operator()(const _Pair& __x) const
> { return __x.first; }
> };
>
> template <class _Pair>
> struct _Select2nd : public unary_function<_Pair,
> typename _Pair::second_type>
> {
> typename _Pair::second_type&
> operator()(_Pair& __x) const
> { return __x.second; }
>
> const typename _Pair::second_type&
> operator()(const _Pair& __x) const
> { return __x.second; }
> };
># 582 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_function.h" 3
> template <class _Ret, class _Tp>
> class mem_fun_t : public unary_function<_Tp*, _Ret>
> {
> public:
> explicit
> mem_fun_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) {}
>
> _Ret
> operator()(_Tp* __p) const
> { return (__p->*_M_f)(); }
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
> template <class _Ret, class _Tp>
> class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
> {
> public:
> explicit
> const_mem_fun_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) {}
>
> _Ret
> operator()(const _Tp* __p) const
> { return (__p->*_M_f)(); }
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
> template <class _Ret, class _Tp>
> class mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> mem_fun_ref_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) {}
>
> _Ret
> operator()(_Tp& __r) const
> { return (__r.*_M_f)(); }
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
> template <class _Ret, class _Tp>
> class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) {}
>
> _Ret
> operator()(const _Tp& __r) const
> { return (__r.*_M_f)(); }
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
> template <class _Ret, class _Tp, class _Arg>
> class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) {}
>
> _Ret
> operator()(_Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
> template <class _Ret, class _Tp, class _Arg>
> class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) {}
>
> _Ret
> operator()(const _Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
> template <class _Ret, class _Tp, class _Arg>
> class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) {}
>
> _Ret
> operator()(_Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
> template <class _Ret, class _Tp, class _Arg>
> class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) {}
>
> _Ret
> operator()(const _Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template <class _Ret, class _Tp>
> inline mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)())
> { return mem_fun_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _Tp>
> inline const_mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _Tp>
> inline mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)())
> { return mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _Tp>
> inline const_mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _Tp, class _Arg>
> inline mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template <class _Ret, class _Tp, class _Arg>
> inline const_mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template <class _Ret, class _Tp, class _Arg>
> inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
> template <class _Ret, class _Tp, class _Arg>
> inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
>
>
>}
># 52 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/atomicity.h" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/atomicity.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/atomic_word.h" 1 3
># 33 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/atomic_word.h" 3
>typedef int _Atomic_word;
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/atomicity.h" 2 3
>
>namespace __gnu_cxx
>{
> _Atomic_word
> __attribute__ ((__unused__))
> __exchange_and_add(volatile _Atomic_word* __mem, int __val);
>
> void
> __attribute__ ((__unused__))
> __atomic_add(volatile _Atomic_word* __mem, int __val);
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 2 3
>
>
>namespace std
>{
># 109 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_string
> {
> typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
>
>
> public:
> typedef _Traits traits_type;
> typedef typename _Traits::char_type value_type;
> typedef _Alloc allocator_type;
> typedef typename _CharT_alloc_type::size_type size_type;
> typedef typename _CharT_alloc_type::difference_type difference_type;
> typedef typename _CharT_alloc_type::reference reference;
> typedef typename _CharT_alloc_type::const_reference const_reference;
> typedef typename _CharT_alloc_type::pointer pointer;
> typedef typename _CharT_alloc_type::const_pointer const_pointer;
> typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
>
> private:
># 146 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> struct _Rep_base
> {
> size_type _M_length;
> size_type _M_capacity;
> _Atomic_word _M_refcount;
> };
>
> struct _Rep : _Rep_base
> {
>
> typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
># 171 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> static const size_type _S_max_size;
> static const _CharT _S_terminal;
>
>
>
> static size_type _S_empty_rep_storage[];
>
> static _Rep&
> _S_empty_rep()
> {
> void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
> return *reinterpret_cast<_Rep*>(__p);
> }
>
> bool
> _M_is_leaked() const
> { return this->_M_refcount < 0; }
>
> bool
> _M_is_shared() const
> { return this->_M_refcount > 0; }
>
> void
> _M_set_leaked()
> { this->_M_refcount = -1; }
>
> void
> _M_set_sharable()
> { this->_M_refcount = 0; }
>
> void
> _M_set_length_and_sharable(size_type __n)
> {
> this->_M_set_sharable();
> this->_M_length = __n;
> traits_type::assign(this->_M_refdata()[__n], _S_terminal);
>
>
> }
>
> _CharT*
> _M_refdata() throw()
> { return reinterpret_cast<_CharT*>(this + 1); }
>
> _CharT*
> _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
> {
> return (!_M_is_leaked() && __alloc1 == __alloc2)
> ? _M_refcopy() : _M_clone(__alloc1);
> }
>
>
> static _Rep*
> _S_create(size_type, size_type, const _Alloc&);
>
> void
> _M_dispose(const _Alloc& __a)
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> if (__gnu_cxx::__exchange_and_add(&this->_M_refcount, -1) <= 0)
> _M_destroy(__a);
> }
>
> void
> _M_destroy(const _Alloc&) throw();
>
> _CharT*
> _M_refcopy() throw()
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> __gnu_cxx::__atomic_add(&this->_M_refcount, 1);
> return _M_refdata();
> }
>
> _CharT*
> _M_clone(const _Alloc&, size_type __res = 0);
> };
>
>
> struct _Alloc_hider : _Alloc
> {
> _Alloc_hider(_CharT* __dat, const _Alloc& __a)
> : _Alloc(__a), _M_p(__dat) { }
>
> _CharT* _M_p;
> };
>
> public:
>
>
>
>
> static const size_type npos = static_cast<size_type>(-1);
>
> private:
>
> mutable _Alloc_hider _M_dataplus;
>
> _CharT*
> _M_data() const
> { return _M_dataplus._M_p; }
>
> _CharT*
> _M_data(_CharT* __p)
> { return (_M_dataplus._M_p = __p); }
>
> _Rep*
> _M_rep() const
> { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
>
>
>
> iterator
> _M_ibegin() const
> { return iterator(_M_data()); }
>
> iterator
> _M_iend() const
> { return iterator(_M_data() + this->size()); }
>
> void
> _M_leak()
> {
> if (!_M_rep()->_M_is_leaked())
> _M_leak_hard();
> }
>
> size_type
> _M_check(size_type __pos, const char* __s) const
> {
> if (__pos > this->size())
> __throw_out_of_range((__s));
> return __pos;
> }
>
> void
> _M_check_length(size_type __n1, size_type __n2, const char* __s) const
> {
> if (this->max_size() - (this->size() - __n1) < __n2)
> __throw_length_error((__s));
> }
>
>
> size_type
> _M_limit(size_type __pos, size_type __off) const
> {
> const bool __testoff = __off < this->size() - __pos;
> return __testoff ? __off : this->size() - __pos;
> }
>
>
> bool
> _M_disjunct(const _CharT* __s) const
> {
> return (less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s));
> }
>
>
>
> static void
> _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
> {
> if (__n == 1)
> traits_type::assign(*__d, *__s);
> else
> traits_type::copy(__d, __s, __n);
> }
>
> static void
> _M_move(_CharT* __d, const _CharT* __s, size_type __n)
> {
> if (__n == 1)
> traits_type::assign(*__d, *__s);
> else
> traits_type::move(__d, __s, __n);
> }
>
> static void
> _M_assign(_CharT* __d, size_type __n, _CharT __c)
> {
> if (__n == 1)
> traits_type::assign(*__d, __c);
> else
> traits_type::assign(__d, __n, __c);
> }
>
>
>
> template<class _Iterator>
> static void
> _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
> {
> for (; __k1 != __k2; ++__k1, ++__p)
> traits_type::assign(*__p, *__k1);
> }
>
> static void
> _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
> { _M_copy(__p, __k1, __k2 - __k1); }
>
> static void
> _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
> { _M_copy(__p, __k1, __k2 - __k1); }
>
> void
> _M_mutate(size_type __pos, size_type __len1, size_type __len2);
>
> void
> _M_leak_hard();
>
> static _Rep&
> _S_empty_rep()
> { return _Rep::_S_empty_rep(); }
>
> public:
>
>
>
>
>
>
>
> inline
> basic_string();
>
>
>
>
> explicit
> basic_string(const _Alloc& __a);
>
>
>
>
>
>
> basic_string(const basic_string& __str);
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n = npos);
>
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a);
># 448 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string(const _CharT* __s, size_type __n,
> const _Alloc& __a = _Alloc());
>
>
>
>
>
> basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
>
>
>
>
>
>
> basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
>
>
>
>
>
>
>
> template<class _InputIterator>
> basic_string(_InputIterator __beg, _InputIterator __end,
> const _Alloc& __a = _Alloc());
>
>
>
>
> ~basic_string()
> { _M_rep()->_M_dispose(this->get_allocator()); }
>
>
>
>
>
> basic_string&
> operator=(const basic_string& __str)
> { return this->assign(__str); }
>
>
>
>
>
> basic_string&
> operator=(const _CharT* __s)
> { return this->assign(__s); }
># 503 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> operator=(_CharT __c)
> {
> this->assign(1, __c);
> return *this;
> }
>
>
>
>
>
>
> iterator
> begin()
> {
> _M_leak();
> return iterator(_M_data());
> }
>
>
>
>
>
> const_iterator
> begin() const
> { return const_iterator(_M_data()); }
>
>
>
>
>
> iterator
> end()
> {
> _M_leak();
> return iterator(_M_data() + this->size());
> }
>
>
>
>
>
> const_iterator
> end() const
> { return const_iterator(_M_data() + this->size()); }
>
>
>
>
>
>
> reverse_iterator
> rbegin()
> { return reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> reverse_iterator
> rend()
> { return reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const
> { return const_reverse_iterator(this->begin()); }
>
> public:
>
>
>
> size_type
> size() const
> { return _M_rep()->_M_length; }
>
>
>
> size_type
> length() const
> { return _M_rep()->_M_length; }
>
>
> size_type
> max_size() const
> { return _Rep::_S_max_size; }
># 614 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> void
> resize(size_type __n, _CharT __c);
># 627 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> void
> resize(size_type __n)
> { this->resize(__n, _CharT()); }
>
>
>
>
>
> size_type
> capacity() const
> { return _M_rep()->_M_capacity; }
># 656 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> void
> reserve(size_type __res_arg = 0);
>
>
>
>
> void
> clear()
> { _M_mutate(0, this->size(), 0); }
>
>
>
>
> bool
> empty() const
> { return this->size() == 0; }
># 684 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> const_reference
> operator[] (size_type __pos) const
> {
> ;
> return _M_data()[__pos];
> }
># 701 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> reference
> operator[](size_type __pos)
> {
>
> ;
>
> ;
> _M_leak();
> return _M_data()[__pos];
> }
># 722 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> const_reference
> at(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("basic_string::at"));
> return _M_data()[__n];
> }
># 741 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> reference
> at(size_type __n)
> {
> if (__n >= size())
> __throw_out_of_range(("basic_string::at"));
> _M_leak();
> return _M_data()[__n];
> }
>
>
>
>
>
>
>
> basic_string&
> operator+=(const basic_string& __str)
> { return this->append(__str); }
>
>
>
>
>
>
> basic_string&
> operator+=(const _CharT* __s)
> { return this->append(__s); }
>
>
>
>
>
>
> basic_string&
> operator+=(_CharT __c)
> {
> this->push_back(__c);
> return *this;
> }
>
>
>
>
>
>
> basic_string&
> append(const basic_string& __str);
># 801 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> append(const basic_string& __str, size_type __pos, size_type __n);
>
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s, size_type __n);
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s)
> {
> ;
> return this->append(__s, traits_type::length(__s));
> }
># 833 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> append(size_type __n, _CharT __c);
># 844 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> append(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_iend(), _M_iend(), __first, __last); }
>
>
>
>
>
> void
> push_back(_CharT __c)
> {
> const size_type __len = 1 + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> traits_type::assign(_M_data()[this->size()], __c);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
>
>
>
>
>
>
> basic_string&
> assign(const basic_string& __str);
># 883 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> assign(const basic_string& __str, size_type __pos, size_type __n)
> { return this->assign(__str._M_data()
> + __str._M_check(__pos, "basic_string::assign"),
> __str._M_limit(__pos, __n)); }
># 899 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s, size_type __n);
># 911 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s)
> {
> ;
> return this->assign(__s, traits_type::length(__s));
> }
># 927 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> assign(size_type __n, _CharT __c)
> { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
># 939 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> assign(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
># 956 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> void
> insert(iterator __p, size_type __n, _CharT __c)
> { this->replace(__p, __p, __n, __c); }
># 971 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<class _InputIterator>
> void
> insert(iterator __p, _InputIterator __beg, _InputIterator __end)
> { this->replace(__p, __p, __beg, __end); }
># 987 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str)
> { return this->insert(__pos1, __str, size_type(0), __str.size()); }
># 1009 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str,
> size_type __pos2, size_type __n)
> { return this->insert(__pos1, __str._M_data()
> + __str._M_check(__pos2, "basic_string::insert"),
> __str._M_limit(__pos2, __n)); }
># 1032 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s, size_type __n);
># 1050 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s)
> {
> ;
> return this->insert(__pos, __s, traits_type::length(__s));
> }
># 1073 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, size_type __n, _CharT __c)
> { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
> size_type(0), __n, __c); }
># 1090 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> iterator
> insert(iterator __p, _CharT __c)
> {
> ;
> const size_type __pos = __p - _M_ibegin();
> _M_replace_aux(__pos, size_type(0), size_type(1), __c);
> _M_rep()->_M_set_leaked();
> return this->_M_ibegin() + __pos;
> }
># 1114 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> erase(size_type __pos = 0, size_type __n = npos)
> {
> _M_mutate(_M_check(__pos, "basic_string::erase"),
> _M_limit(__pos, __n), size_type(0));
> return *this;
> }
># 1130 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> iterator
> erase(iterator __position)
> {
> ;
>
> const size_type __pos = __position - _M_ibegin();
> _M_mutate(__pos, size_type(1), size_type(0));
> _M_rep()->_M_set_leaked();
> return _M_ibegin() + __pos;
> }
># 1150 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> iterator
> erase(iterator __first, iterator __last)
> {
> ;
>
> const size_type __pos = __first - _M_ibegin();
> _M_mutate(__pos, __last - __first, size_type(0));
> _M_rep()->_M_set_leaked();
> return _M_ibegin() + __pos;
> }
># 1177 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n, const basic_string& __str)
> { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
># 1199 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2)
> { return this->replace(__pos1, __n1, __str._M_data()
> + __str._M_check(__pos2, "basic_string::replace"),
> __str._M_limit(__pos2, __n2)); }
># 1223 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2);
># 1242 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s)
> {
> ;
> return this->replace(__pos, __n1, __s, traits_type::length(__s));
> }
># 1265 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
> { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
> _M_limit(__pos, __n1), __n2, __c); }
># 1283 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const basic_string& __str)
> { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
># 1301 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
> {
> ;
>
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
> }
># 1322 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const _CharT* __s)
> {
> ;
> return this->replace(__i1, __i2, __s, traits_type::length(__s));
> }
># 1343 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
> {
> ;
>
> return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
> }
># 1365 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> replace(iterator __i1, iterator __i2,
> _InputIterator __k1, _InputIterator __k2)
> {
> ;
>
> ;
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
> }
>
>
>
> basic_string&
> replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
> {
> ;
>
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2,
> const _CharT* __k1, const _CharT* __k2)
> {
> ;
>
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
> {
> ;
>
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2,
> const_iterator __k1, const_iterator __k2)
> {
> ;
>
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
>
> private:
> template<class _Integer>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
> _Integer __val, __true_type)
> { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
>
> template<class _InputIterator>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
> _InputIterator __k2, __false_type);
>
> basic_string&
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c);
>
> basic_string&
> _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2);
>
>
>
> template<class _InIterator>
> static _CharT*
> _S_construct_aux(_InIterator __beg, _InIterator __end,
> const _Alloc& __a, __false_type)
> {
> typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
> return _S_construct(__beg, __end, __a, _Tag());
> }
>
> template<class _InIterator>
> static _CharT*
> _S_construct_aux(_InIterator __beg, _InIterator __end,
> const _Alloc& __a, __true_type)
> { return _S_construct(static_cast<size_type>(__beg),
> static_cast<value_type>(__end), __a); }
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
> {
> typedef typename std::__is_integer<_InIterator>::__type _Integral;
> return _S_construct_aux(__beg, __end, __a, _Integral());
> }
>
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> input_iterator_tag);
>
>
>
> template<class _FwdIterator>
> static _CharT*
> _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
> forward_iterator_tag);
>
> static _CharT*
> _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
>
> public:
># 1496 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
># 1506 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> void
> swap(basic_string& __s);
># 1516 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> const _CharT*
> c_str() const
> { return _M_data(); }
>
>
>
>
>
>
>
> const _CharT*
> data() const
> { return _M_data(); }
>
>
>
>
> allocator_type
> get_allocator() const
> { return _M_dataplus; }
># 1548 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos, size_type __n) const;
># 1561 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find(const basic_string& __str, size_type __pos = 0) const
> { return this->find(__str.data(), __pos, __str.size()); }
># 1575 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos = 0) const
> {
> ;
> return this->find(__s, __pos, traits_type::length(__s));
> }
># 1592 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find(_CharT __c, size_type __pos = 0) const;
># 1605 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> rfind(const basic_string& __str, size_type __pos = npos) const
> { return this->rfind(__str.data(), __pos, __str.size()); }
># 1620 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos, size_type __n) const;
># 1633 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->rfind(__s, __pos, traits_type::length(__s));
> }
># 1650 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> rfind(_CharT __c, size_type __pos = npos) const;
># 1663 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_of(const basic_string& __str, size_type __pos = 0) const
> { return this->find_first_of(__str.data(), __pos, __str.size()); }
># 1678 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1691 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos = 0) const
> {
> ;
> return this->find_first_of(__s, __pos, traits_type::length(__s));
> }
># 1710 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_of(_CharT __c, size_type __pos = 0) const
> { return this->find(__c, __pos); }
># 1724 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_of(const basic_string& __str, size_type __pos = npos) const
> { return this->find_last_of(__str.data(), __pos, __str.size()); }
># 1739 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1752 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->find_last_of(__s, __pos, traits_type::length(__s));
> }
># 1771 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_of(_CharT __c, size_type __pos = npos) const
> { return this->rfind(__c, __pos); }
># 1785 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_not_of(const basic_string& __str, size_type __pos = 0) const
> { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
># 1800 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 1814 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos = 0) const
> {
> ;
> return this->find_first_not_of(__s, __pos, traits_type::length(__s));
> }
># 1831 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const;
># 1844 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_not_of(const basic_string& __str, size_type __pos = npos) const
> { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
># 1860 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 1873 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->find_last_not_of(__s, __pos, traits_type::length(__s));
> }
># 1890 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const;
># 1905 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> basic_string
> substr(size_type __pos = 0, size_type __n = npos) const
> { return basic_string(*this,
> _M_check(__pos, "basic_string::substr"), __n); }
># 1923 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> int
> compare(const basic_string& __str) const
> {
> const size_type __size = this->size();
> const size_type __osize = __str.size();
> const size_type __len = std::min(__size, __osize);
>
> int __r = traits_type::compare(_M_data(), __str.data(), __len);
> if (!__r)
> __r = __size - __osize;
> return __r;
> }
># 1953 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n, const basic_string& __str) const;
># 1977 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> int
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const;
># 1995 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> int
> compare(const _CharT* __s) const;
># 2018 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s) const;
># 2043 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const;
> };
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>::
> basic_string()
>
> : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
># 2064 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str(__lhs);
> __str.append(__size_type(1), __rhs);
> return __str;
> }
># 2135 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) == 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) == 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) == 0; }
># 2172 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) != 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) != 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) != 0; }
># 2209 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) > 0; }
># 2246 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) < 0; }
># 2283 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) >= 0; }
># 2320 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) <= 0; }
># 2357 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline void
> swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { __lhs.swap(__rhs); }
># 2374 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str);
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __is, basic_string<char>& __str);
># 2392 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os,
> const basic_string<_CharT, _Traits, _Alloc>& __str);
># 2410 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
># 2427 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str);
>
> template<>
> basic_istream<char>&
> getline(basic_istream<char>& __in, basic_string<char>& __str,
> char __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
> wchar_t __delim);
>
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/algorithm" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/algorithm" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/algorithm" 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 1 3
># 65 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 1 3
># 65 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
>namespace std
>{
>
>
>
> template<typename _RandomAccessIterator, typename _Distance>
> bool
> __is_heap(_RandomAccessIterator __first, _Distance __n)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__first[__parent] < __first[__child])
> return false;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return true;
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _StrictWeakOrdering>
> bool
> __is_heap(_RandomAccessIterator __first, _StrictWeakOrdering __comp,
> _Distance __n)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__comp(__first[__parent], __first[__child]))
> return false;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return true;
> }
>
> template<typename _RandomAccessIterator>
> bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::__is_heap(__first, std::distance(__first, __last)); }
>
> template<typename _RandomAccessIterator, typename _StrictWeakOrdering>
> bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _StrictWeakOrdering __comp)
> { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
>
>
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
> void
> __push_heap(_RandomAccessIterator __first,
> _Distance __holeIndex, _Distance __topIndex, _Tp __value)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> while (__holeIndex > __topIndex && *(__first + __parent) < __value)
> {
> *(__first + __holeIndex) = *(__first + __parent);
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = __value;
> }
># 139 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
>
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), _ValueType(*(__last - 1)));
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
> typename _Compare>
> void
> __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __topIndex, _Tp __value, _Compare __comp)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> while (__holeIndex > __topIndex
> && __comp(*(__first + __parent), __value))
> {
> *(__first + __holeIndex) = *(__first + __parent);
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = __value;
> }
># 187 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> ;
> ;
>
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), _ValueType(*(__last - 1)), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
> void
> __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __len, _Tp __value)
> {
> const _Distance __topIndex = __holeIndex;
> _Distance __secondChild = 2 * __holeIndex + 2;
> while (__secondChild < __len)
> {
> if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
> __secondChild--;
> *(__first + __holeIndex) = *(__first + __secondChild);
> __holeIndex = __secondChild;
> __secondChild = 2 * (__secondChild + 1);
> }
> if (__secondChild == __len)
> {
> *(__first + __holeIndex) = *(__first + (__secondChild - 1));
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex, __value);
> }
>
> template<typename _RandomAccessIterator, typename _Tp>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result, _Tp __value)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> *__result = *__first;
> std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
> __value);
> }
># 251 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> std::__pop_heap(__first, __last - 1, __last - 1,
> _ValueType(*(__last - 1)));
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Tp, typename _Compare>
> void
> __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __len, _Tp __value, _Compare __comp)
> {
> const _Distance __topIndex = __holeIndex;
> _Distance __secondChild = 2 * __holeIndex + 2;
> while (__secondChild < __len)
> {
> if (__comp(*(__first + __secondChild),
> *(__first + (__secondChild - 1))))
> __secondChild--;
> *(__first + __holeIndex) = *(__first + __secondChild);
> __holeIndex = __secondChild;
> __secondChild = 2 * (__secondChild + 1);
> }
> if (__secondChild == __len)
> {
> *(__first + __holeIndex) = *(__first + (__secondChild - 1));
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result, _Tp __value, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> *__result = *__first;
> std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
> __value, __comp);
> }
># 317 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> pop_heap(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> std::__pop_heap(__first, __last - 1, __last - 1,
> _ValueType(*(__last - 1)), __comp);
> }
># 342 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
> if (__last - __first < 2)
> return;
>
> const _DistanceType __len = __last - __first;
> _DistanceType __parent = (__len - 2) / 2;
> while (true)
> {
> std::__adjust_heap(__first, __parent, __len,
> _ValueType(*(__first + __parent)));
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 382 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> ;
>
> if (__last - __first < 2)
> return;
>
> const _DistanceType __len = __last - __first;
> _DistanceType __parent = (__len - 2) / 2;
> while (true)
> {
> std::__adjust_heap(__first, __parent, __len,
> _ValueType(*(__first + __parent)), __comp);
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 420 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
>
>
> while (__last - __first > 1)
> std::pop_heap(__first, __last--);
> }
># 446 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> while (__last - __first > 1)
> std::pop_heap(__first, __last--, __comp);
> }
>
>}
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_tempbuf.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_tempbuf.h" 3
>namespace std
>{
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> class _Temporary_buffer
> {
>
> 
>
> public:
> typedef _Tp value_type;
> typedef value_type* pointer;
> typedef pointer iterator;
> typedef ptrdiff_t size_type;
>
> protected:
> size_type _M_original_len;
> size_type _M_len;
> pointer _M_buffer;
>
> void
> _M_initialize_buffer(const _Tp&, __true_type) { }
>
> void
> _M_initialize_buffer(const _Tp& val, __false_type)
> { std::uninitialized_fill_n(_M_buffer, _M_len, val); }
>
> public:
>
> size_type
> size() const
> { return _M_len; }
>
>
> size_type
> requested_size() const
> { return _M_original_len; }
>
>
> iterator
> begin()
> { return _M_buffer; }
>
>
> iterator
> end()
> { return _M_buffer + _M_len; }
>
>
>
>
>
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
>
> ~_Temporary_buffer()
> {
> std::_Destroy(_M_buffer, _M_buffer + _M_len);
> std::return_temporary_buffer(_M_buffer);
> }
>
> private:
>
> _Temporary_buffer(const _Temporary_buffer&);
>
> void
> operator=(const _Temporary_buffer&);
> };
>
>
> template<typename _ForwardIterator, typename _Tp>
> _Temporary_buffer<_ForwardIterator, _Tp>::
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
> : _M_original_len(std::distance(__first, __last)),
> _M_len(0), _M_buffer(0)
> {
>
> typedef typename std::__is_scalar<_Tp>::__type _Trivial;
>
> try
> {
> pair<pointer, size_type> __p(get_temporary_buffer<
> value_type>(_M_original_len));
> _M_buffer = __p.first;
> _M_len = __p.second;
> if (_M_len > 0)
> _M_initialize_buffer(*__first, _Trivial());
> }
> catch(...)
> {
> std::return_temporary_buffer(_M_buffer);
> _M_buffer = 0;
> _M_len = 0;
> throw;
> }
> }
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 2 3
>
>
>
>
>namespace std
>{
># 85 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _Tp>
> inline const _Tp&
> __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
> {
>
> 
> if (__a < __b)
> if (__b < __c)
> return __b;
> else if (__a < __c)
> return __c;
> else
> return __a;
> else if (__a < __c)
> return __a;
> else if (__b < __c)
> return __c;
> else
> return __b;
> }
># 119 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
> {
>
> 
> if (__comp(__a, __b))
> if (__comp(__b, __c))
> return __b;
> else if (__comp(__a, __c))
> return __c;
> else
> return __a;
> else if (__comp(__a, __c))
> return __a;
> else if (__comp(__b, __c))
> return __c;
> else
> return __b;
> }
># 151 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Function>
> _Function
> for_each(_InputIterator __first, _InputIterator __last, _Function __f)
> {
>
> 
> ;
> for ( ; __first != __last; ++__first)
> __f(*__first);
> return __f;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> __find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val, input_iterator_tag)
> {
> while (__first != __last && !(*__first == __val))
> ++__first;
> return __first;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && !__pred(*__first))
> ++__first;
> return __first;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
> const _Tp& __val, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for ( ; __trip_count > 0 ; --__trip_count)
> {
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (*__first == __val)
> return __first;
> ++__first;
> case 2:
> if (*__first == __val)
> return __first;
> ++__first;
> case 1:
> if (*__first == __val)
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _RandomAccessIterator
> __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Predicate __pred, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for ( ; __trip_count > 0 ; --__trip_count)
> {
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 2:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 1:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
># 305 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
> return std::__find(__first, __last, __val,
> std::__iterator_category(__first));
> }
># 327 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::__find_if(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 349 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (*__first == *__next)
> return __first;
> __first = __next;
> }
> return __last;
> }
># 380 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (__binary_pred(*__first, *__next))
> return __first;
> __first = __next;
> }
> return __last;
> }
># 411 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> typename iterator_traits<_InputIterator>::difference_type
> count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
> {
>
> 
> 
>
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for ( ; __first != __last; ++__first)
> if (*__first == __value)
> ++__n;
> return __n;
> }
># 435 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> typename iterator_traits<_InputIterator>::difference_type
> count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> {
>
> 
> 
>
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for ( ; __first != __last; ++__first)
> if (__pred(*__first))
> ++__n;
> return __n;
> }
># 474 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __tmp(__first2);
> ++__tmp;
> if (__tmp == __last2)
> return std::find(__first1, __last1, *__first2);
>
>
> _ForwardIterator2 __p1, __p;
> __p1 = __first2; ++__p1;
> _ForwardIterator1 __current = __first1;
>
> while (__first1 != __last1)
> {
> __first1 = std::find(__first1, __last1, *__first2);
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (*__current == *__p)
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 545 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __predicate)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __tmp(__first2);
> ++__tmp;
> if (__tmp == __last2)
> {
> while (__first1 != __last1 && !__predicate(*__first1, *__first2))
> ++__first1;
> return __first1;
> }
>
>
> _ForwardIterator2 __p1, __p;
> __p1 = __first2; ++__p1;
> _ForwardIterator1 __current = __first1;
>
> while (__first1 != __last1)
> {
> while (__first1 != __last1)
> {
> if (__predicate(*__first1, *__first2))
> break;
> ++__first1;
> }
> while (__first1 != __last1 && !__predicate(*__first1, *__first2))
> ++__first1;
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (__predicate(*__current, *__p))
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 617 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> std::forward_iterator_tag)
> {
> __first = std::find(__first, __last, __val);
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && *__i == __val)
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = std::find(++__i, __last, __val);
> }
> return __last;
> }
># 651 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIter, typename _Integer, typename _Tp>
> _RandomAccessIter
> __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, const _Tp& __val,
> std::random_access_iterator_tag)
> {
>
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> const _DistanceType __pattSize = __count;
>
> if (__tailSize < __pattSize)
> return __last;
>
> const _DistanceType __skipOffset = __pattSize - 1;
> _RandomAccessIter __lookAhead = __first + __skipOffset;
> __tailSize -= __pattSize;
>
> while (1)
> {
>
>
> while (!(*__lookAhead == __val))
> {
> if (__tailSize < __pattSize)
> return __last;
> __lookAhead += __pattSize;
> __tailSize -= __pattSize;
> }
> _DistanceType __remainder = __skipOffset;
> for (_RandomAccessIter __backTrack = __lookAhead - 1;
> *__backTrack == __val; --__backTrack)
> {
> if (--__remainder == 0)
> return (__lookAhead - __skipOffset);
> }
> if (__remainder > __tailSize)
> return __last;
> __lookAhead += __remainder;
> __tailSize -= __remainder;
> }
> }
># 709 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> if (__count == 1)
> return std::find(__first, __last, __val);
> return std::__search_n(__first, __last, __count, __val,
> std::__iterator_category(__first));
> }
># 736 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred, std::forward_iterator_tag)
> {
> while (__first != __last && !__binary_pred(*__first, __val))
> ++__first;
>
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && __binary_pred(*__i, __val))
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = ++__i;
> while (__first != __last && !__binary_pred(*__first, __val))
> ++__first;
> }
> return __last;
> }
># 776 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIter, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _RandomAccessIter
> __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
> {
>
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> const _DistanceType __pattSize = __count;
>
> if (__tailSize < __pattSize)
> return __last;
>
> const _DistanceType __skipOffset = __pattSize - 1;
> _RandomAccessIter __lookAhead = __first + __skipOffset;
> __tailSize -= __pattSize;
>
> while (1)
> {
>
>
> while (!__binary_pred(*__lookAhead, __val))
> {
> if (__tailSize < __pattSize)
> return __last;
> __lookAhead += __pattSize;
> __tailSize -= __pattSize;
> }
> _DistanceType __remainder = __skipOffset;
> for (_RandomAccessIter __backTrack = __lookAhead - 1;
> __binary_pred(*__backTrack, __val); --__backTrack)
> {
> if (--__remainder == 0)
> return (__lookAhead - __skipOffset);
> }
> if (__remainder > __tailSize)
> return __last;
> __lookAhead += __remainder;
> __tailSize -= __remainder;
> }
> }
># 837 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> if (__count == 1)
> {
> while (__first != __last && !__binary_pred(*__first, __val))
> ++__first;
> return __first;
> }
> return std::__search_n(__first, __last, __count, __val, __binary_pred,
> std::__iterator_category(__first));
> }
># 873 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator2
> swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
> 
>
> 
>
> 
>
>
> 
>
>
> ;
>
> for ( ; __first1 != __last1; ++__first1, ++__first2)
> std::iter_swap(__first1, __first2);
> return __first2;
> }
># 911 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _UnaryOperation>
> _OutputIterator
> transform(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _UnaryOperation __unary_op)
> {
>
> 
> 
>
>
> ;
>
> for ( ; __first != __last; ++__first, ++__result)
> *__result = __unary_op(*__first);
> return __result;
> }
># 946 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _BinaryOperation>
> _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;
> }
># 978 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> 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;
> }
># 1009 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate, typename _Tp>
> void
> replace_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (__pred(*__first))
> *__first = __new_value;
> }
># 1042 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _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;
> }
># 1078 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate, typename _Tp>
> _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;
> }
># 1112 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Generator>
> void
> generate(_ForwardIterator __first, _ForwardIterator __last,
> _Generator __gen)
> {
>
> 
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> *__first = __gen();
> }
># 1138 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _OutputIterator, typename _Size, typename _Generator>
> _OutputIterator
> generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
> {
>
> 
>
>
>
> for ( ; __n > 0; --__n, ++__first)
> *__first = __gen();
> return __first;
> }
># 1165 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> remove_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, const _Tp& __value)
> {
>
> 
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (!(*__first == __value))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 1201 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> remove_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (!__pred(*__first))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 1240 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> remove(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find(__first, __last, __value);
> _ForwardIterator __i = __first;
> return __first == __last ? __first
> : std::remove_copy(++__i, __last,
> __first, __value);
> }
># 1275 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> remove_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find_if(__first, __last, __pred);
> _ForwardIterator __i = __first;
> return __first == __last ? __first
> : std::remove_copy_if(++__i, __last,
> __first, __pred);
> }
># 1301 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> output_iterator_tag)
> {
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!(__value == *__first))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
># 1326 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> forward_iterator_tag)
> {
>
> *__result = *__first;
> while (++__first != __last)
> if (!(*__result == *__first))
> *++__result = *__first;
> return ++__result;
> }
># 1348 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _BinaryPredicate __binary_pred,
> output_iterator_tag)
> {
>
> 
>
>
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!__binary_pred(__value, *__first))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
># 1380 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> _BinaryPredicate __binary_pred,
> forward_iterator_tag)
> {
>
> 
>
>
>
> *__result = *__first;
> while (++__first != __last)
> if (!__binary_pred(*__result, *__first)) *++__result = *__first;
> return ++__result;
> }
># 1412 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> 
>
> ;
>
> typedef typename iterator_traits<_OutputIterator>::iterator_category
> _IterType;
>
> if (__first == __last) return __result;
> return std::__unique_copy(__first, __last, __result, _IterType());
> }
># 1447 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> typedef typename iterator_traits<_OutputIterator>::iterator_category
> _IterType;
>
> if (__first == __last) return __result;
> return std::__unique_copy(__first, __last, __result,
> __binary_pred, _IterType());
> }
># 1481 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
>
> 
>
> ;
>
>
> __first = std::adjacent_find(__first, __last);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!(*__dest == *__first))
> *++__dest = *__first;
> return ++__dest;
> }
># 1520 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
>
> 
>
>
> ;
>
>
> __first = std::adjacent_find(__first, __last, __binary_pred);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!__binary_pred(*__dest, *__first))
> *++__dest = *__first;
> return ++__dest;
> }
># 1554 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> void
> __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
> while (true)
> if (__first == __last || __first == --__last)
> return;
> else
> {
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
># 1576 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> void
> __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
> if (__first == __last)
> return;
> --__last;
> while (__first < __last)
> {
> std::iter_swap(__first, __last);
> ++__first;
> --__last;
> }
> }
># 1603 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline void
> reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
> {
>
> 
>
> ;
> std::__reverse(__first, __last, std::__iterator_category(__first));
> }
># 1629 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _OutputIterator>
> _OutputIterator
> reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _OutputIterator __result)
> {
>
> 
>
> 
>
> ;
>
> while (__first != __last)
> {
> --__last;
> *__result = *__last;
> ++__result;
> }
> return __result;
> }
># 1657 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _EuclideanRingElement>
> _EuclideanRingElement
> __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
> {
> while (__n != 0)
> {
> _EuclideanRingElement __t = __m % __n;
> __m = __n;
> __n = __t;
> }
> return __m;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator>
> void
> __rotate(_ForwardIterator __first,
> _ForwardIterator __middle,
> _ForwardIterator __last,
> forward_iterator_tag)
> {
> if (__first == __middle || __last == __middle)
> return;
>
> _ForwardIterator __first2 = __middle;
> do
> {
> swap(*__first, *__first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> }
> while (__first2 != __last);
>
> __first2 = __middle;
>
> while (__first2 != __last)
> {
> swap(*__first, *__first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> else if (__first2 == __last)
> __first2 = __middle;
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator>
> void
> __rotate(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle || __last == __middle)
> return;
>
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
>
> while (__first != __middle && __middle != __last)
> {
> swap(*__first, *--__last);
> ++__first;
> }
>
> if (__first == __middle)
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
> else
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __rotate(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle || __last == __middle)
> return;
>
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> const _Distance __n = __last - __first;
> const _Distance __k = __middle - __first;
> const _Distance __l = __n - __k;
>
> if (__k == __l)
> {
> std::swap_ranges(__first, __middle, __middle);
> return;
> }
>
> const _Distance __d = __gcd(__n, __k);
>
> for (_Distance __i = 0; __i < __d; __i++)
> {
> _ValueType __tmp = *__first;
> _RandomAccessIterator __p = __first;
>
> if (__k < __l)
> {
> for (_Distance __j = 0; __j < __l / __d; __j++)
> {
> if (__p > __first + __l)
> {
> *__p = *(__p - __l);
> __p -= __l;
> }
>
> *__p = *(__p + __k);
> __p += __k;
> }
> }
> else
> {
> for (_Distance __j = 0; __j < __k / __d - 1; __j ++)
> {
> if (__p < __last - __k)
> {
> *__p = *(__p + __k);
> __p += __k;
> }
> *__p = * (__p - __l);
> __p -= __l;
> }
> }
>
> *__p = __tmp;
> ++__first;
> }
> }
># 1836 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline void
> rotate(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last)
> {
>
> 
>
> ;
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::iterator_category
> _IterType;
> std::__rotate(__first, __middle, __last, _IterType());
> }
># 1869 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _OutputIterator>
> _OutputIterator
> rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last, _OutputIterator __result)
> {
>
> 
> 
>
> ;
> ;
>
> return std::copy(__first, __middle,
> std::copy(__middle, __last, __result));
> }
># 1895 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> ;
>
> if (__first != __last)
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
> }
># 1922 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
> void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomNumberGenerator& __rand)
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __rand((__i - __first) + 1));
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> __partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred,
> forward_iterator_tag)
> {
> if (__first == __last)
> return __first;
>
> while (__pred(*__first))
> if (++__first == __last)
> return __first;
>
> _ForwardIterator __next = __first;
>
> while (++__next != __last)
> if (__pred(*__next))
> {
> swap(*__first, *__next);
> ++__first;
> }
>
> return __first;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Predicate>
> _BidirectionalIterator
> __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _Predicate __pred,
> bidirectional_iterator_tag)
> {
> while (true)
> {
> while (true)
> if (__first == __last)
> return __first;
> else if (__pred(*__first))
> ++__first;
> else
> break;
> --__last;
> while (true)
> if (__first == __last)
> return __first;
> else if (!__pred(*__last))
> --__last;
> else
> break;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
># 2016 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__partition(__first, __last, __pred,
> std::__iterator_category(__first));
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Predicate, typename _Distance>
> _ForwardIterator
> __inplace_stable_partition(_ForwardIterator __first,
> _ForwardIterator __last,
> _Predicate __pred, _Distance __len)
> {
> if (__len == 1)
> return __pred(*__first) ? __last : __first;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __begin = std::__inplace_stable_partition(__first,
> __middle,
> __pred,
> __len / 2);
> _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
> __pred,
> __len
> - __len / 2);
> std::rotate(__begin, __middle, __end);
> std::advance(__begin, std::distance(__middle, __end));
> return __begin;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
> typename _Distance>
> _ForwardIterator
> __stable_partition_adaptive(_ForwardIterator __first,
> _ForwardIterator __last,
> _Predicate __pred, _Distance __len,
> _Pointer __buffer,
> _Distance __buffer_size)
> {
> if (__len <= __buffer_size)
> {
> _ForwardIterator __result1 = __first;
> _Pointer __result2 = __buffer;
> for ( ; __first != __last ; ++__first)
> if (__pred(*__first))
> {
> *__result1 = *__first;
> ++__result1;
> }
> else
> {
> *__result2 = *__first;
> ++__result2;
> }
> std::copy(__buffer, __result2, __result1);
> return __result1;
> }
> else
> {
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __begin =
> std::__stable_partition_adaptive(__first, __middle, __pred,
> __len / 2, __buffer,
> __buffer_size);
> _ForwardIterator __end =
> std::__stable_partition_adaptive(__middle, __last, __pred,
> __len - __len / 2,
> __buffer, __buffer_size);
> std::rotate(__begin, __middle, __end);
> std::advance(__begin, std::distance(__middle, __end));
> return __begin;
> }
> }
># 2127 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> stable_partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return __first;
> else
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.size() > 0)
> return
> std::__stable_partition_adaptive(__first, __last, __pred,
> _DistanceType(__buf.requested_size()),
> __buf.begin(), __buf.size());
> else
> return
> std::__inplace_stable_partition(__first, __last, __pred,
> _DistanceType(__buf.requested_size()));
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Tp __pivot)
> {
> while (true)
> {
> while (*__first < __pivot)
> ++__first;
> --__last;
> while (__pivot < *__last)
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Tp __pivot, _Compare __comp)
> {
> while (true)
> {
> while (__comp(*__first, __pivot))
> ++__first;
> --__last;
> while (__comp(__pivot, *__last))
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
>
> enum { _S_threshold = 16 };
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val)
> {
> _RandomAccessIterator __next = __last;
> --__next;
> while (__val < *__next)
> {
> *__last = *__next;
> __last = __next;
> --__next;
> }
> *__last = __val;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val,
> _Compare __comp)
> {
> _RandomAccessIterator __next = __last;
> --__next;
> while (__comp(__val, *__next))
> {
> *__last = *__next;
> __last = __next;
> --__next;
> }
> *__last = __val;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__first == __last)
> return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = *__i;
> if (__val < *__first)
> {
> std::copy_backward(__first, __i, __i + 1);
> *__first = __val;
> }
> else
> std::__unguarded_linear_insert(__i, __val);
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__first == __last) return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = *__i;
> if (__comp(__val, *__first))
> {
> std::copy_backward(__first, __i, __i + 1);
> *__first = __val;
> }
> else
> std::__unguarded_linear_insert(__i, __val, __comp);
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, _ValueType(*__i));
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, _ValueType(*__i), __comp);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first > int(_S_threshold))
> {
> std::__insertion_sort(__first, __first + int(_S_threshold));
> std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
> }
> else
> std::__insertion_sort(__first, __last);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first > int(_S_threshold))
> {
> std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
> std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
> __comp);
> }
> else
> std::__insertion_sort(__first, __last, __comp);
> }
>
>
>
>
>
>
> template<typename _Size>
> inline _Size
> __lg(_Size __n)
> {
> _Size __k;
> for (__k = 0; __n != 1; __n >>= 1)
> ++__k;
> return __k;
> }
># 2416 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> std::make_heap(__first, __middle);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (*__i < *__first)
> std::__pop_heap(__first, __middle, __i, _ValueType(*__i));
> std::sort_heap(__first, __middle);
> }
># 2457 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> std::make_heap(__first, __middle, __comp);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (__comp(*__i, *__first))
> std::__pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
> std::sort_heap(__first, __middle, __comp);
> }
># 2499 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator>
> _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
> 
> ;
> ;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while(__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
> std::make_heap(__result_first, __result_real_last);
> while (__first != __last)
> {
> if (*__first < *__result_first)
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first));
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last);
> return __result_real_last;
> }
># 2563 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
> _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while(__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
> std::make_heap(__result_first, __result_real_last, __comp);
> while (__first != __last)
> {
> if (__comp(*__first, *__result_first))
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first),
> __comp);
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last, __comp);
> return __result_real_last;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Size>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > int(_S_threshold))
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last
> - 1))));
> std::__introsort_loop(__cut, __last, __depth_limit);
> __last = __cut;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > int(_S_threshold))
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last, __comp);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last - 1),
> __comp)),
> __comp);
> std::__introsort_loop(__cut, __last, __depth_limit, __comp);
> __last = __cut;
> }
> }
># 2698 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last, __lg(__last - __first) * 2);
> std::__final_insertion_sort(__first, __last);
> }
> }
># 2732 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last, __lg(__last - __first) * 2,
> __comp);
> std::__final_insertion_sort(__first, __last, __comp);
> }
> }
># 2765 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>
>
>
>
> 
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 2820 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 2867 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>
> 
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__val < *__middle)
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
># 2919 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (*__middle < *__first)
> std::iter_swap(__first, __middle);
> return;
> }
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut);
> __len11 = std::distance(__first, __first_cut);
> }
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22);
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Compare>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Compare __comp)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (__comp(*__middle, *__first))
> std::iter_swap(__first, __middle);
> return;
> }
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22, __comp);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22, __comp);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle);
> std::__inplace_stable_sort(__middle, __last);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last, __comp);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle, __comp);
> std::__inplace_stable_sort(__middle, __last, __comp);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle,
> __comp);
> }
># 3117 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 3175 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result,
> _Distance __step_size)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::merge(__first, __first + __step_size,
> __first + __step_size, __first + __two_step,
> __result);
> __first += __two_step;
> }
>
> __step_size = std::min(_Distance(__last - __first), __step_size);
> std::merge(__first, __first + __step_size, __first + __step_size, __last,
> __result);
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance, typename _Compare>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result, _Distance __step_size,
> _Compare __comp)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::merge(__first, __first + __step_size,
> __first + __step_size, __first + __two_step,
> __result,
> __comp);
> __first += __two_step;
> }
> __step_size = std::min(_Distance(__last - __first), __step_size);
>
> std::merge(__first, __first + __step_size,
> __first + __step_size, __last,
> __result,
> __comp);
> }
>
> enum { _S_chunk_size = 7 };
>
> template<typename _RandomAccessIterator, typename _Distance>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Compare>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size, _Compare __comp)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size, __comp);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer, __step_size);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
> __step_size *= 2;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer,
> __step_size, __comp);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first,
> __step_size, __comp);
> __step_size *= 2;
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3>
> _BidirectionalIterator3
> __merge_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result)
> {
> if (__first1 == __last1)
> return std::copy_backward(__first2, __last2, __result);
> if (__first2 == __last2)
> return std::copy_backward(__first1, __last1, __result);
> --__last1;
> --__last2;
> while (true)
> {
> if (*__last2 < *__last1)
> {
> *--__result = *__last1;
> if (__first1 == __last1)
> return std::copy_backward(__first2, ++__last2, __result);
> --__last1;
> }
> else
> {
> *--__result = *__last2;
> if (__first2 == __last2)
> return std::copy_backward(__first1, ++__last1, __result);
> --__last2;
> }
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3, typename _Compare>
> _BidirectionalIterator3
> __merge_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result,
> _Compare __comp)
> {
> if (__first1 == __last1)
> return std::copy_backward(__first2, __last2, __result);
> if (__first2 == __last2)
> return std::copy_backward(__first1, __last1, __result);
> --__last1;
> --__last2;
> while (true)
> {
> if (__comp(*__last2, *__last1))
> {
> *--__result = *__last1;
> if (__first1 == __last1)
> return std::copy_backward(__first2, ++__last2, __result);
> --__last1;
> }
> else
> {
> *--__result = *__last2;
> if (__first2 == __last2)
> return std::copy_backward(__first1, ++__last1, __result);
> --__last2;
> }
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _Distance>
> _BidirectionalIterator1
> __rotate_adaptive(_BidirectionalIterator1 __first,
> _BidirectionalIterator1 __middle,
> _BidirectionalIterator1 __last,
> _Distance __len1, _Distance __len2,
> _BidirectionalIterator2 __buffer,
> _Distance __buffer_size)
> {
> _BidirectionalIterator2 __buffer_end;
> if (__len1 > __len2 && __len2 <= __buffer_size)
> {
> __buffer_end = std::copy(__middle, __last, __buffer);
> std::copy_backward(__first, __middle, __last);
> return std::copy(__buffer, __buffer_end, __first);
> }
> else if (__len1 <= __buffer_size)
> {
> __buffer_end = std::copy(__first, __middle, __buffer);
> std::copy(__middle, __last, __first);
> return std::copy_backward(__buffer, __buffer_end, __last);
> }
> else
> {
> std::rotate(__first, __middle, __last);
> std::advance(__first, std::distance(__middle, __last));
> return __first;
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
> std::merge(__buffer, __buffer_end, __middle, __last, __first);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
> std::__merge_backward(__first, __middle, __buffer,
> __buffer_end, __last);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last,
> *__first_cut);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle,
> *__second_cut);
> __len11 = std::distance(__first, __first_cut);
> }
> _BidirectionalIterator __new_middle =
> std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer, __buffer_size);
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance, typename _Pointer,
> typename _Compare>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
> std::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
> std::__merge_backward(__first, __middle, __buffer, __buffer_end,
> __last, __comp);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
> _BidirectionalIterator __new_middle =
> std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size, __comp);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer,
> __buffer_size, __comp);
> }
> }
># 3595 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> _DistanceType __len1 = std::distance(__first, __middle);
> _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()));
> }
># 3649 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
>
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> const _DistanceType __len1 = std::distance(__first, __middle);
> const _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1,
> __len2, __comp);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()),
> __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle,
> __buffer, __buffer_size);
> std::__stable_sort_adaptive(__middle, __last,
> __buffer, __buffer_size);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer);
> std::__merge_sort_with_buffer(__middle, __last, __buffer);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance, typename _Compare>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle, __buffer,
> __buffer_size, __comp);
> std::__stable_sort_adaptive(__middle, __last, __buffer,
> __buffer_size, __comp);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
> std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size,
> __comp);
> }
># 3758 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType>
> buf(__first, __last);
> if (buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last);
> else
> std::__stable_sort_adaptive(__first, __last, buf.begin(),
> _DistanceType(buf.size()));
> }
># 3799 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
>
>
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
> if (buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last, __comp);
> else
> std::__stable_sort_adaptive(__first, __last, buf.begin(),
> _DistanceType(buf.size()), __comp);
> }
># 3840 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> void
> nth_element(_RandomAccessIterator __first,
> _RandomAccessIterator __nth,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> while (__last - __first > 3)
> {
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last
> - 1))));
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last);
> }
># 3891 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> nth_element(_RandomAccessIterator __first,
> _RandomAccessIterator __nth,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> while (__last - __first > 3)
> {
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last - 1),
> __comp)), __comp);
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
># 3944 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>
> 
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle, __left, __right;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__val < *__middle)
> __len = __half;
> else
> {
> __left = std::lower_bound(__first, __middle, __val);
> std::advance(__first, __len);
> __right = std::upper_bound(++__middle, __first, __val);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 4006 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val,
> _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle, __left, __right;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> __left = std::lower_bound(__first, __middle, __val, __comp);
> std::advance(__first, __len);
> __right = std::upper_bound(++__middle, __first, __val, __comp);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 4064 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
>
> 
> 
>
> 
> ;
>
> _ForwardIterator __i = std::lower_bound(__first, __last, __val);
> return __i != __last && !(__val < *__i);
> }
># 4096 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
>
> 
> 
>
> 
>
> ;
>
> _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
> return __i != __last && !__comp(__val, *__i);
> }
># 4134 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
>
> 
> 
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
> return false;
> else if(*__first1 < *__first2)
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 4180 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
> return false;
> else if(__comp(*__first1, *__first2))
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 4226 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 4288 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 4349 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> ++__first1;
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 4403 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> ++__first1;
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 4457 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 4515 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 4569 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2, std::copy(__first1,
> __last1, __result));
> }
># 4630 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result,
> _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2, std::copy(__first1,
> __last1, __result));
> }
># 4683 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__result < *__first)
> __result = __first;
> return __result;
> }
># 4710 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last) return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(*__result, *__first)) __result = __first;
> return __result;
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__first < *__result)
> __result = __first;
> return __result;
> }
># 4762 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(*__first, *__result))
> __result = __first;
> return __result;
> }
># 4797 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__i < *__ii)
> {
> _BidirectionalIterator __j = __last;
> while (!(*__i < *--__j))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4853 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(*__i, *__ii))
> {
> _BidirectionalIterator __j = __last;
> while (!__comp(*__i, *--__j))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4908 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__ii < *__i)
> {
> _BidirectionalIterator __j = __last;
> while (!(*--__j < *__i))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4964 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(*__ii, *__i))
> {
> _BidirectionalIterator __j = __last;
> while (!__comp(*--__j, *__i))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 5023 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for ( ; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (*__first1 == *__iter)
> return __first1;
> return __last1;
> }
># 5059 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for ( ; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (__comp(*__first1, *__iter))
> return __first1;
> return __last1;
> }
># 5089 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2, __last2);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag,
> _BinaryPredicate __comp)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2, __last2, __comp);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
> _RevIterator2(__last2), __rlast2);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BinaryPredicate>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag,
> _BinaryPredicate __comp)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
> _RevIterator2(__last2), __rlast2,
> __comp);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
># 5239 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2));
> }
># 5284 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> __comp);
> }
>
>}
># 69 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/algorithm" 2 3
># 56 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.tcc" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.tcc" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.tcc" 3
>
>namespace std
>{
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type* __ptr)
> { return __ptr == 0; }
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type)
> { return false; }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const _CharT
> basic_string<_CharT, _Traits, _Alloc>::
> _Rep::_S_terminal = _CharT();
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::npos;
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
> (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
> sizeof(size_type)];
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InIterator>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> input_iterator_tag)
> {
>
> if (__beg == __end && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> _CharT __buf[128];
> size_type __len = 0;
> while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
> {
> __buf[__len++] = *__beg;
> ++__beg;
> }
> _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
> _M_copy(__r->_M_refdata(), __buf, __len);
> try
> {
> while (__beg != __end)
> {
> if (__len == __r->_M_capacity)
> {
>
> _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
> _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
> __r->_M_destroy(__a);
> __r = __another;
> }
> __r->_M_refdata()[__len++] = *__beg;
> ++__beg;
> }
> }
> catch(...)
> {
> __r->_M_destroy(__a);
> throw;
> }
> __r->_M_set_length_and_sharable(__len);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template <typename _InIterator>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> forward_iterator_tag)
> {
>
> if (__beg == __end && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> if (__builtin_expect(__is_null_pointer(__beg) && __beg != __end, 0))
> __throw_logic_error(("basic_string::_S_construct NULL not valid"));
>
> const size_type __dnew = static_cast<size_type>(std::distance(__beg,
> __end));
>
> _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
> try
> { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
> catch(...)
> {
> __r->_M_destroy(__a);
> throw;
> }
> __r->_M_set_length_and_sharable(__dnew);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
> {
>
> if (__n == 0 && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
> if (__n)
> _M_assign(__r->_M_refdata(), __n, __c);
>
> __r->_M_set_length_and_sharable(__n);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str)
> : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
> __str.get_allocator()),
> __str.get_allocator())
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _Alloc& __a)
> : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str, size_type __pos, size_type __n)
> : _M_dataplus(_S_construct(__str._M_data()
> + __str._M_check(__pos,
> "basic_string::basic_string"),
> __str._M_data() + __str._M_limit(__pos, __n)
> + __pos, _Alloc()), _Alloc())
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a)
> : _M_dataplus(_S_construct(__str._M_data()
> + __str._M_check(__pos,
> "basic_string::basic_string"),
> __str._M_data() + __str._M_limit(__pos, __n)
> + __pos, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
> : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _CharT* __s, const _Alloc& __a)
> : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
> __s + npos, __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(size_type __n, _CharT __c, const _Alloc& __a)
> : _M_dataplus(_S_construct(__n, __c, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
> : _M_dataplus(_S_construct(__beg, __end, __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> assign(const basic_string& __str)
> {
> if (_M_rep() != __str._M_rep())
> {
>
> const allocator_type __a = this->get_allocator();
> _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
> _M_rep()->_M_dispose(__a);
> _M_data(__tmp);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> assign(const _CharT* __s, size_type __n)
> {
> ;
> _M_check_length(this->size(), __n, "basic_string::assign");
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(size_type(0), this->size(), __s, __n);
> else
> {
>
> const size_type __pos = __s - _M_data();
> if (__pos >= __n)
> _M_copy(_M_data(), __s, __n);
> else if (__pos)
> _M_move(_M_data(), __s, __n);
> _M_rep()->_M_set_length_and_sharable(__n);
> return *this;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(size_type __n, _CharT __c)
> {
> if (__n)
> {
> _M_check_length(size_type(0), __n, "basic_string::append");
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_assign(_M_data() + this->size(), __n, __c);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const _CharT* __s, size_type __n)
> {
> ;
> if (__n)
> {
> _M_check_length(size_type(0), __n, "basic_string::append");
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> {
> if (_M_disjunct(__s))
> this->reserve(__len);
> else
> {
> const size_type __off = __s - _M_data();
> this->reserve(__len);
> __s = _M_data() + __off;
> }
> }
> _M_copy(_M_data() + this->size(), __s, __n);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const basic_string& __str)
> {
> const size_type __size = __str.size();
> if (__size)
> {
> const size_type __len = __size + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_copy(_M_data() + this->size(), __str._M_data(), __size);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const basic_string& __str, size_type __pos, size_type __n)
> {
> __str._M_check(__pos, "basic_string::append");
> __n = __str._M_limit(__pos, __n);
> if (__n)
> {
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> insert(size_type __pos, const _CharT* __s, size_type __n)
> {
> ;
> _M_check(__pos, "basic_string::insert");
> _M_check_length(size_type(0), __n, "basic_string::insert");
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(__pos, size_type(0), __s, __n);
> else
> {
>
> const size_type __off = __s - _M_data();
> _M_mutate(__pos, 0, __n);
> __s = _M_data() + __off;
> _CharT* __p = _M_data() + __pos;
> if (__s + __n <= __p)
> _M_copy(__p, __s, __n);
> else if (__s >= __p)
> _M_copy(__p, __s + __n, __n);
> else
> {
> const size_type __nleft = __p - __s;
> _M_copy(__p, __s, __nleft);
> _M_copy(__p + __nleft, __p + __n, __n - __nleft);
> }
> return *this;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> ;
> _M_check(__pos, "basic_string::replace");
> __n1 = _M_limit(__pos, __n1);
> _M_check_length(__n1, __n2, "basic_string::replace");
> bool __left;
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(__pos, __n1, __s, __n2);
> else if ((__left = __s + __n2 <= _M_data() + __pos)
> || _M_data() + __pos + __n1 <= __s)
> {
>
> size_type __off = __s - _M_data();
> __left ? __off : (__off += __n2 - __n1);
> _M_mutate(__pos, __n1, __n2);
> _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
> return *this;
> }
> else
> {
>
> const basic_string __tmp(__s, __n2);
> return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _M_destroy(const _Alloc& __a) throw ()
> {
> const size_type __size = sizeof(_Rep_base) +
> (this->_M_capacity + 1) * sizeof(_CharT);
> _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_leak_hard()
> {
>
> if (_M_rep() == &_S_empty_rep())
> return;
>
> if (_M_rep()->_M_is_shared())
> _M_mutate(0, 0, 0);
> _M_rep()->_M_set_leaked();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_mutate(size_type __pos, size_type __len1, size_type __len2)
> {
> const size_type __old_size = this->size();
> const size_type __new_size = __old_size + __len2 - __len1;
> const size_type __how_much = __old_size - __pos - __len1;
>
> if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
> {
>
> const allocator_type __a = get_allocator();
> _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
>
> if (__pos)
> _M_copy(__r->_M_refdata(), _M_data(), __pos);
> if (__how_much)
> _M_copy(__r->_M_refdata() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
>
> _M_rep()->_M_dispose(__a);
> _M_data(__r->_M_refdata());
> }
> else if (__how_much && __len1 != __len2)
> {
>
> _M_move(_M_data() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
> }
> _M_rep()->_M_set_length_and_sharable(__new_size);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> reserve(size_type __res)
> {
> if (__res != this->capacity() || _M_rep()->_M_is_shared())
> {
>
> if (__res < this->size())
> __res = this->size();
> const allocator_type __a = get_allocator();
> _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
> _M_rep()->_M_dispose(__a);
> _M_data(__tmp);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> swap(basic_string& __s)
> {
> if (_M_rep()->_M_is_leaked())
> _M_rep()->_M_set_sharable();
> if (__s._M_rep()->_M_is_leaked())
> __s._M_rep()->_M_set_sharable();
> if (this->get_allocator() == __s.get_allocator())
> {
> _CharT* __tmp = _M_data();
> _M_data(__s._M_data());
> __s._M_data(__tmp);
> }
>
> else
> {
> const basic_string __tmp1(_M_ibegin(), _M_iend(),
> __s.get_allocator());
> const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
> this->get_allocator());
> *this = __tmp2;
> __s = __tmp1;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _S_create(size_type __capacity, size_type __old_capacity,
> const _Alloc& __alloc)
> {
>
>
> if (__capacity > _S_max_size)
> __throw_length_error(("basic_string::_S_create"));
># 558 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_string.tcc" 3
> const size_type __pagesize = 4096;
> const size_type __malloc_header_size = 4 * sizeof(void*);
>
>
>
>
>
>
>
> if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
> __capacity = 2 * __old_capacity;
>
>
>
>
> size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
>
> const size_type __adj_size = __size + __malloc_header_size;
> if (__adj_size > __pagesize && __capacity > __old_capacity)
> {
> const size_type __extra = __pagesize - __adj_size % __pagesize;
> __capacity += __extra / sizeof(_CharT);
>
> if (__capacity > _S_max_size)
> __capacity = _S_max_size;
> __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
> }
>
>
>
> void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
> _Rep *__p = new (__place) _Rep;
> __p->_M_capacity = __capacity;
> return __p;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _M_clone(const _Alloc& __alloc, size_type __res)
> {
>
> const size_type __requested_cap = this->_M_length + __res;
> _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
> __alloc);
> if (this->_M_length)
> _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
>
> __r->_M_set_length_and_sharable(this->_M_length);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> resize(size_type __n, _CharT __c)
> {
> const size_type __size = this->size();
> _M_check_length(__size, __n, "basic_string::resize");
> if (__size < __n)
> this->append(__n - __size, __c);
> else if (__n < __size)
> this->erase(__n);
>
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
> _InputIterator __k2, __false_type)
> {
> const basic_string __s(__k1, __k2);
> const size_type __n1 = __i2 - __i1;
> _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
> return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
> __s.size());
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c)
> {
> _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
> _M_mutate(__pos1, __n1, __n2);
> if (__n2)
> _M_assign(_M_data() + __pos1, __n2, __c);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> _M_mutate(__pos1, __n1, __n2);
> if (__n2)
> _M_copy(_M_data() + __pos1, __s, __n2);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> ;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> const __size_type __len = _Traits::length(__lhs);
> __string_type __str;
> __str.reserve(__len + __rhs.size());
> __str.append(__lhs, __len);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str;
> const __size_type __len = __rhs.size();
> __str.reserve(__len + 1);
> __str.append(__size_type(1), __lhs);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> copy(_CharT* __s, size_type __n, size_type __pos) const
> {
> _M_check(__pos, "basic_string::copy");
> __n = _M_limit(__pos, __n);
> ;
> if (__n)
> _M_copy(__s, _M_data() + __pos, __n);
>
> return __n;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __ret = npos;
> const size_type __size = this->size();
> if (__pos + __n <= __size)
> {
> const _CharT* __data = _M_data();
> const _CharT* __p = std::search(__data + __pos, __data + __size,
> __s, __s + __n, traits_type::eq);
> if (__p != __data + __size || __n == 0)
> __ret = __p - __data;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(_CharT __c, size_type __pos) const
> {
> size_type __ret = npos;
> const size_type __size = this->size();
> if (__pos < __size)
> {
> const _CharT* __data = _M_data();
> const size_type __n = __size - __pos;
> const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
> if (__p)
> __ret = __p - __data;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> const size_type __size = this->size();
> if (__n <= __size)
> {
> __pos = std::min(size_type(__size - __n), __pos);
> const _CharT* __data = _M_data();
> do
> {
> if (traits_type::compare(__data + __pos, __s, __n) == 0)
> return __pos;
> }
> while (__pos-- > 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(_CharT __c, size_type __pos) const
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> for (++__size; __size-- > 0; )
> if (traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> for (; __n && __pos < this->size(); ++__pos)
> {
> const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
> if (__p)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __size = this->size();
> if (__size && __n)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size-- != 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::find(__s, __n, _M_data()[__pos]))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(_CharT __c, size_type __pos) const
> {
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::eq(_M_data()[__pos], __c))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(_CharT __c, size_type __pos) const
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n, const basic_string& __str) const
> {
> _M_check(__pos, "basic_string::compare");
> __n = _M_limit(__pos, __n);
> const size_type __osize = __str.size();
> const size_type __len = std::min(__n, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
> if (!__r)
> __r = __n - __osize;
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const
> {
> _M_check(__pos1, "basic_string::compare");
> __str._M_check(__pos2, "basic_string::compare");
> __n1 = _M_limit(__pos1, __n1);
> __n2 = __str._M_limit(__pos2, __n2);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos1,
> __str.data() + __pos2, __len);
> if (!__r)
> __r = __n1 - __n2;
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(const _CharT* __s) const
> {
> ;
> const size_type __size = this->size();
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__size, __osize);
> int __r = traits_type::compare(_M_data(), __s, __len);
> if (!__r)
> __r = __size - __osize;
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__n1, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = __n1 - __osize;
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = __n1 - __n2;
> return __r;
> }
>
>
>
>
>
> extern template class basic_string<char>;
> extern template
> basic_istream<char>&
> operator>>(basic_istream<char>&, string&);
> extern template
> basic_ostream<char>&
> operator<<(basic_ostream<char>&, const string&);
> extern template
> basic_istream<char>&
> getline(basic_istream<char>&, string&, char);
> extern template
> basic_istream<char>&
> getline(basic_istream<char>&, string&);
>
>
> extern template class basic_string<wchar_t>;
> extern template
> basic_istream<wchar_t>&
> operator>>(basic_istream<wchar_t>&, wstring&);
> extern template
> basic_ostream<wchar_t>&
> operator<<(basic_ostream<wchar_t>&, const wstring&);
> extern template
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>&, wstring&, wchar_t);
> extern template
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>&, wstring&);
>
>
>}
># 57 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/string" 2 3
># 10 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 1 3
># 41 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 3
> 
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 3
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/localefwd.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/localefwd.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/localefwd.h" 3
>
>
>
>
>
>
>namespace std
>{
>
> class locale;
>
>
> template<typename _CharT>
> inline bool
> isspace(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isprint(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> iscntrl(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isupper(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> islower(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isalpha(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isdigit(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> ispunct(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isxdigit(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isalnum(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isgraph(_CharT, const locale&);
>
> template<typename _CharT>
> inline _CharT
> toupper(_CharT, const locale&);
>
> template<typename _CharT>
> inline _CharT
> tolower(_CharT, const locale&);
>
>
> class ctype_base;
> template<typename _CharT>
> class ctype;
> template<> class ctype<char>;
>
> template<> class ctype<wchar_t>;
>
> template<typename _CharT>
> class ctype_byname;
>
>
> class codecvt_base;
> class __enc_traits;
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt;
> template<> class codecvt<char, char, mbstate_t>;
>
> template<> class codecvt<wchar_t, char, mbstate_t>;
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname;
>
>
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class num_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class num_put;
>
> template<typename _CharT> class numpunct;
> template<typename _CharT> class numpunct_byname;
>
>
> template<typename _CharT>
> class collate;
> template<typename _CharT> class
> collate_byname;
>
>
> class time_base;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get_byname;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put_byname;
>
>
> class money_base;
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class money_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class money_put;
>
> template<typename _CharT, bool _Intl = false>
> class moneypunct;
> template<typename _CharT, bool _Intl = false>
> class moneypunct_byname;
>
>
> class messages_base;
> template<typename _CharT>
> class messages;
> template<typename _CharT>
> class messages_byname;
>
> template<typename _Facet>
> bool
> has_facet(const locale& __loc) throw();
>
> template<typename _Facet>
> const _Facet&
> use_facet(const locale& __loc);
>
> template<typename _Facet>
> inline const _Facet&
> __check_facet(const _Facet* __f)
> {
> if (!__f)
> __throw_bad_cast();
> return *__f;
> }
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
>
>
>
>
>
>
>
>namespace std
>{
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> class locale
> {
> public:
>
>
> typedef int category;
>
>
> class facet;
> class id;
> class _Impl;
>
> friend class facet;
> friend class _Impl;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
># 105 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> static const category none = 0;
> static const category ctype = 1L << 0;
> static const category numeric = 1L << 1;
> static const category collate = 1L << 2;
> static const category time = 1L << 3;
> static const category monetary = 1L << 4;
> static const category messages = 1L << 5;
> static const category all = (ctype | numeric | collate |
> time | monetary | messages);
># 124 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> locale() throw();
># 133 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> locale(const locale& __other) throw();
># 143 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> explicit
> locale(const char* __s);
># 158 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> locale(const locale& __base, const char* __s, category __cat);
># 171 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> locale(const locale& __base, const locale& __add, category __cat);
># 183 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> template<typename _Facet>
> locale(const locale& __other, _Facet* __f);
>
>
> ~locale() throw();
># 197 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> const locale&
> operator=(const locale& __other) throw();
># 212 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> template<typename _Facet>
> locale
> combine(const locale& __other) const;
>
>
>
>
>
>
> string
> name() const;
># 231 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> bool
> operator==(const locale& __other) const throw ();
>
>
>
>
>
>
>
> inline bool
> operator!=(const locale& __other) const throw ()
> { return !(this->operator==(__other)); }
># 259 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> template<typename _Char, typename _Traits, typename _Alloc>
> bool
> operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
> const basic_string<_Char, _Traits, _Alloc>& __s2) const;
># 275 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> static locale
> global(const locale&);
>
>
>
>
> static const locale&
> classic();
>
> private:
>
> _Impl* _M_impl;
>
>
> static _Impl* _S_classic;
>
>
> static _Impl* _S_global;
>
>
>
>
>
> static const char* const* const _S_categories;
># 310 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> enum { _S_categories_size = 6 + 6 };
>
>
> static __gthread_once_t _S_once;
>
>
> explicit
> locale(_Impl*) throw();
>
> static void
> _S_initialize();
>
> static void
> _S_initialize_once();
>
> static category
> _S_normalize_category(category);
>
> void
> _M_coalesce(const locale& __base, const locale& __add, category __cat);
> };
># 343 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> class locale::facet
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> mutable _Atomic_word _M_refcount;
>
>
> static __c_locale _S_c_locale;
>
>
> static const char _S_c_name[2];
>
>
> static __gthread_once_t _S_once;
>
>
> static void
> _S_initialize_once();
>
> protected:
># 374 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> explicit
> facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
> { }
>
>
> virtual
> ~facet();
>
> static void
> _S_create_c_locale(__c_locale& __cloc, const char* __s,
> __c_locale __old = 0);
>
> static __c_locale
> _S_clone_c_locale(__c_locale& __cloc);
>
> static void
> _S_destroy_c_locale(__c_locale& __cloc);
>
>
>
> static __c_locale
> _S_get_c_locale();
>
> static const char*
> _S_get_c_name();
>
> private:
> inline void
> _M_add_reference() const throw()
> { __gnu_cxx::__atomic_add(&_M_refcount, 1); }
>
> inline void
> _M_remove_reference() const throw()
> {
> if (__gnu_cxx::__exchange_and_add(&_M_refcount, -1) == 1)
> {
> try
> { delete this; }
> catch (...)
> { }
> }
> }
>
> facet(const facet&);
>
> facet&
> operator=(const facet&);
> };
># 434 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_classes.h" 3
> class locale::id
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw ();
>
>
>
>
> mutable size_t _M_index;
>
>
> static _Atomic_word _S_refcount;
>
> void
> operator=(const id&);
>
> id(const id&);
>
> public:
>
>
>
> id() { }
>
> size_t
> _M_id() const;
> };
>
>
>
> class locale::_Impl
> {
> public:
>
> friend class locale;
> friend class locale::facet;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
>
> private:
>
> _Atomic_word _M_refcount;
> const facet** _M_facets;
> size_t _M_facets_size;
> const facet** _M_caches;
> char** _M_names;
> static const locale::id* const _S_id_ctype[];
> static const locale::id* const _S_id_numeric[];
> static const locale::id* const _S_id_collate[];
> static const locale::id* const _S_id_time[];
> static const locale::id* const _S_id_monetary[];
> static const locale::id* const _S_id_messages[];
> static const locale::id* const* const _S_facet_categories[];
>
> inline void
> _M_add_reference() throw()
> { __gnu_cxx::__atomic_add(&_M_refcount, 1); }
>
> inline void
> _M_remove_reference() throw()
> {
> if (__gnu_cxx::__exchange_and_add(&_M_refcount, -1) == 1)
> {
> try
> { delete this; }
> catch(...)
> { }
> }
> }
>
> _Impl(const _Impl&, size_t);
> _Impl(const char*, size_t);
> _Impl(size_t) throw();
>
> ~_Impl() throw();
>
> _Impl(const _Impl&);
>
> void
> operator=(const _Impl&);
>
> inline bool
> _M_check_same_name()
> {
> bool __ret = true;
> if (_M_names[1])
>
> for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
> __ret = std::strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
> return __ret;
> }
>
> void
> _M_replace_categories(const _Impl*, category);
>
> void
> _M_replace_category(const _Impl*, const locale::id* const*);
>
> void
> _M_replace_facet(const _Impl*, const locale::id*);
>
> void
> _M_install_facet(const locale::id*, const facet*);
>
> template<typename _Facet>
> inline void
> _M_init_facet(_Facet* __facet)
> { _M_install_facet(&_Facet::id, __facet); }
>
> void
> _M_install_cache(const facet*, size_t);
> };
>
> template<typename _Facet>
> locale::locale(const locale& __other, _Facet* __f)
> {
> _M_impl = new _Impl(*__other._M_impl, 1);
>
> try
> { _M_impl->_M_install_facet(&_Facet::id, __f); }
> catch(...)
> {
> _M_impl->_M_remove_reference();
> throw;
> }
> delete [] _M_impl->_M_names[0];
> _M_impl->_M_names[0] = 0;
> }
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 2 3
>
>namespace std
>{
>
>
>
>
> enum _Ios_Fmtflags
> {
> _S_boolalpha = 1L << 0,
> _S_dec = 1L << 1,
> _S_fixed = 1L << 2,
> _S_hex = 1L << 3,
> _S_internal = 1L << 4,
> _S_left = 1L << 5,
> _S_oct = 1L << 6,
> _S_right = 1L << 7,
> _S_scientific = 1L << 8,
> _S_showbase = 1L << 9,
> _S_showpoint = 1L << 10,
> _S_showpos = 1L << 11,
> _S_skipws = 1L << 12,
> _S_unitbuf = 1L << 13,
> _S_uppercase = 1L << 14,
> _S_adjustfield = _S_left | _S_right | _S_internal,
> _S_basefield = _S_dec | _S_oct | _S_hex,
> _S_floatfield = _S_scientific | _S_fixed,
> _S_ios_fmtflags_end = 1L << 16
> };
>
> inline _Ios_Fmtflags
> operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline _Ios_Fmtflags
> operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline _Ios_Fmtflags
> operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline _Ios_Fmtflags&
> operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a | __b; }
>
> inline _Ios_Fmtflags&
> operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a & __b; }
>
> inline _Ios_Fmtflags&
> operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a ^ __b; }
>
> inline _Ios_Fmtflags
> operator~(_Ios_Fmtflags __a)
> { return _Ios_Fmtflags(~static_cast<int>(__a)); }
>
>
> enum _Ios_Openmode
> {
> _S_app = 1L << 0,
> _S_ate = 1L << 1,
> _S_bin = 1L << 2,
> _S_in = 1L << 3,
> _S_out = 1L << 4,
> _S_trunc = 1L << 5,
> _S_ios_openmode_end = 1L << 16
> };
>
> inline _Ios_Openmode
> operator&(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline _Ios_Openmode
> operator|(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline _Ios_Openmode
> operator^(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline _Ios_Openmode&
> operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a | __b; }
>
> inline _Ios_Openmode&
> operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a & __b; }
>
> inline _Ios_Openmode&
> operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a ^ __b; }
>
> inline _Ios_Openmode
> operator~(_Ios_Openmode __a)
> { return _Ios_Openmode(~static_cast<int>(__a)); }
>
>
> enum _Ios_Iostate
> {
> _S_goodbit = 0,
> _S_badbit = 1L << 0,
> _S_eofbit = 1L << 1,
> _S_failbit = 1L << 2,
> _S_ios_iostate_end = 1L << 16
> };
>
> inline _Ios_Iostate
> operator&(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline _Ios_Iostate
> operator|(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline _Ios_Iostate
> operator^(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline _Ios_Iostate&
> operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a | __b; }
>
> inline _Ios_Iostate&
> operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a & __b; }
>
> inline _Ios_Iostate&
> operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a ^ __b; }
>
> inline _Ios_Iostate
> operator~(_Ios_Iostate __a)
> { return _Ios_Iostate(~static_cast<int>(__a)); }
>
> enum _Ios_Seekdir
> {
> _S_beg = 0,
> _S_cur = 1,
> _S_end = 2,
> _S_ios_seekdir_end = 1L << 16
> };
># 201 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> class ios_base
> {
> public:
>
>
>
> class failure : public exception
> {
> public:
>
>
> explicit
> failure(const string& __str) throw();
>
>
>
> virtual
> ~failure() throw();
>
> virtual const char*
> what() const throw();
>
> private:
> string _M_msg;
> };
># 253 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> typedef _Ios_Fmtflags fmtflags;
>
>
> static const fmtflags boolalpha = _S_boolalpha;
>
>
> static const fmtflags dec = _S_dec;
>
>
> static const fmtflags fixed = _S_fixed;
>
>
> static const fmtflags hex = _S_hex;
>
>
>
>
> static const fmtflags internal = _S_internal;
>
>
>
> static const fmtflags left = _S_left;
>
>
> static const fmtflags oct = _S_oct;
>
>
>
> static const fmtflags right = _S_right;
>
>
> static const fmtflags scientific = _S_scientific;
>
>
>
> static const fmtflags showbase = _S_showbase;
>
>
>
> static const fmtflags showpoint = _S_showpoint;
>
>
> static const fmtflags showpos = _S_showpos;
>
>
> static const fmtflags skipws = _S_skipws;
>
>
> static const fmtflags unitbuf = _S_unitbuf;
>
>
>
> static const fmtflags uppercase = _S_uppercase;
>
>
> static const fmtflags adjustfield = _S_adjustfield;
>
>
> static const fmtflags basefield = _S_basefield;
>
>
> static const fmtflags floatfield = _S_floatfield;
># 328 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> typedef _Ios_Iostate iostate;
>
>
>
> static const iostate badbit = _S_badbit;
>
>
> static const iostate eofbit = _S_eofbit;
>
>
>
>
> static const iostate failbit = _S_failbit;
>
>
> static const iostate goodbit = _S_goodbit;
># 359 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> typedef _Ios_Openmode openmode;
>
>
> static const openmode app = _S_app;
>
>
> static const openmode ate = _S_ate;
>
>
>
>
>
> static const openmode binary = _S_bin;
>
>
> static const openmode in = _S_in;
>
>
> static const openmode out = _S_out;
>
>
> static const openmode trunc = _S_trunc;
># 392 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> typedef _Ios_Seekdir seekdir;
>
>
> static const seekdir beg = _S_beg;
>
>
> static const seekdir cur = _S_cur;
>
>
> static const seekdir end = _S_end;
>
>
> typedef int io_state;
> typedef int open_mode;
> typedef int seek_dir;
>
> typedef std::streampos streampos;
> typedef std::streamoff streamoff;
># 418 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> enum event
> {
> erase_event,
> imbue_event,
> copyfmt_event
> };
># 435 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> typedef void (*event_callback) (event, ios_base&, int);
># 447 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> void
> register_callback(event_callback __fn, int __index);
>
> protected:
>
>
>
>
>
>
> streamsize _M_precision;
> streamsize _M_width;
> fmtflags _M_flags;
> iostate _M_exception;
> iostate _M_streambuf_state;
>
>
>
>
> struct _Callback_list
> {
>
> _Callback_list* _M_next;
> ios_base::event_callback _M_fn;
> int _M_index;
> _Atomic_word _M_refcount;
>
> _Callback_list(ios_base::event_callback __fn, int __index,
> _Callback_list* __cb)
> : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
>
> void
> _M_add_reference() { __gnu_cxx::__atomic_add(&_M_refcount, 1); }
>
>
> int
> _M_remove_reference()
> { return __gnu_cxx::__exchange_and_add(&_M_refcount, -1); }
> };
>
> _Callback_list* _M_callbacks;
>
> void
> _M_call_callbacks(event __ev) throw();
>
> void
> _M_dispose_callbacks(void);
>
>
> struct _Words
> {
> void* _M_pword;
> long _M_iword;
> _Words() : _M_pword(0), _M_iword(0) { }
> };
>
>
> _Words _M_word_zero;
>
>
>
> enum { _S_local_word_size = 8 };
> _Words _M_local_word[_S_local_word_size];
>
>
> int _M_word_size;
> _Words* _M_word;
>
> _Words&
> _M_grow_words(int __index, bool __iword);
>
>
> locale _M_ios_locale;
>
> void
> _M_init();
>
> public:
>
>
>
>
>
> class Init
> {
> friend class ios_base;
> public:
> Init();
> ~Init();
>
> private:
> static _Atomic_word _S_refcount;
> static bool _S_synced_with_stdio;
> };
>
>
>
>
>
>
> inline fmtflags
> flags() const { return _M_flags; }
># 557 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline fmtflags
> flags(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags = __fmtfl;
> return __old;
> }
># 573 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline fmtflags
> setf(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags |= __fmtfl;
> return __old;
> }
># 590 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline fmtflags
> setf(fmtflags __fmtfl, fmtflags __mask)
> {
> fmtflags __old = _M_flags;
> _M_flags &= ~__mask;
> _M_flags |= (__fmtfl & __mask);
> return __old;
> }
>
>
>
>
>
>
>
> inline void
> unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
># 617 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline streamsize
> precision() const { return _M_precision; }
>
>
>
>
>
>
> inline streamsize
> precision(streamsize __prec)
> {
> streamsize __old = _M_precision;
> _M_precision = __prec;
> return __old;
> }
>
>
>
>
>
>
>
> inline streamsize
> width() const { return _M_width; }
>
>
>
>
>
>
> inline streamsize
> width(streamsize __wide)
> {
> streamsize __old = _M_width;
> _M_width = __wide;
> return __old;
> }
># 666 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> static bool
> sync_with_stdio(bool __sync = true);
># 678 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> locale
> imbue(const locale& __loc);
># 689 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline locale
> getloc() const { return _M_ios_locale; }
># 699 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline const locale&
> _M_getloc() const { return _M_ios_locale; }
># 717 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> static int
> xalloc() throw();
># 733 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline long&
> iword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, true);
> return __word._M_iword;
> }
># 754 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> inline void*&
> pword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, false);
> return __word._M_pword;
> }
># 771 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ios_base.h" 3
> virtual ~ios_base();
>
> protected:
> ios_base();
>
>
>
> private:
> ios_base(const ios_base&);
>
> ios_base&
> operator=(const ios_base&);
> };
>
>
>
> inline ios_base&
> boolalpha(ios_base& __base)
> {
> __base.setf(ios_base::boolalpha);
> return __base;
> }
>
>
> inline ios_base&
> noboolalpha(ios_base& __base)
> {
> __base.unsetf(ios_base::boolalpha);
> return __base;
> }
>
>
> inline ios_base&
> showbase(ios_base& __base)
> {
> __base.setf(ios_base::showbase);
> return __base;
> }
>
>
> inline ios_base&
> noshowbase(ios_base& __base)
> {
> __base.unsetf(ios_base::showbase);
> return __base;
> }
>
>
> inline ios_base&
> showpoint(ios_base& __base)
> {
> __base.setf(ios_base::showpoint);
> return __base;
> }
>
>
> inline ios_base&
> noshowpoint(ios_base& __base)
> {
> __base.unsetf(ios_base::showpoint);
> return __base;
> }
>
>
> inline ios_base&
> showpos(ios_base& __base)
> {
> __base.setf(ios_base::showpos);
> return __base;
> }
>
>
> inline ios_base&
> noshowpos(ios_base& __base)
> {
> __base.unsetf(ios_base::showpos);
> return __base;
> }
>
>
> inline ios_base&
> skipws(ios_base& __base)
> {
> __base.setf(ios_base::skipws);
> return __base;
> }
>
>
> inline ios_base&
> noskipws(ios_base& __base)
> {
> __base.unsetf(ios_base::skipws);
> return __base;
> }
>
>
> inline ios_base&
> uppercase(ios_base& __base)
> {
> __base.setf(ios_base::uppercase);
> return __base;
> }
>
>
> inline ios_base&
> nouppercase(ios_base& __base)
> {
> __base.unsetf(ios_base::uppercase);
> return __base;
> }
>
>
> inline ios_base&
> unitbuf(ios_base& __base)
> {
> __base.setf(ios_base::unitbuf);
> return __base;
> }
>
>
> inline ios_base&
> nounitbuf(ios_base& __base)
> {
> __base.unsetf(ios_base::unitbuf);
> return __base;
> }
>
>
>
> inline ios_base&
> internal(ios_base& __base)
> {
> __base.setf(ios_base::internal, ios_base::adjustfield);
> return __base;
> }
>
>
> inline ios_base&
> left(ios_base& __base)
> {
> __base.setf(ios_base::left, ios_base::adjustfield);
> return __base;
> }
>
>
> inline ios_base&
> right(ios_base& __base)
> {
> __base.setf(ios_base::right, ios_base::adjustfield);
> return __base;
> }
>
>
>
> inline ios_base&
> dec(ios_base& __base)
> {
> __base.setf(ios_base::dec, ios_base::basefield);
> return __base;
> }
>
>
> inline ios_base&
> hex(ios_base& __base)
> {
> __base.setf(ios_base::hex, ios_base::basefield);
> return __base;
> }
>
>
> inline ios_base&
> oct(ios_base& __base)
> {
> __base.setf(ios_base::oct, ios_base::basefield);
> return __base;
> }
>
>
>
> inline ios_base&
> fixed(ios_base& __base)
> {
> __base.setf(ios_base::fixed, ios_base::floatfield);
> return __base;
> }
>
>
> inline ios_base&
> scientific(ios_base& __base)
> {
> __base.setf(ios_base::scientific, ios_base::floatfield);
> return __base;
> }
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
>
>
>
>
>
>
>namespace std
>{
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout);
># 121 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> template<typename _CharT, typename _Traits>
> class basic_streambuf
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
># 144 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
>
>
> friend class basic_ios<char_type, traits_type>;
> friend class basic_istream<char_type, traits_type>;
> friend class basic_ostream<char_type, traits_type>;
> friend class istreambuf_iterator<char_type, traits_type>;
> friend class ostreambuf_iterator<char_type, traits_type>;
>
> friend streamsize
> __copy_streambufs<>(__streambuf_type* __sbin,
> __streambuf_type* __sbout);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> getline(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
>
> protected:
># 182 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> char_type* _M_in_beg;
> char_type* _M_in_cur;
> char_type* _M_in_end;
> char_type* _M_out_beg;
> char_type* _M_out_cur;
> char_type* _M_out_end;
>
>
>
>
>
>
> locale _M_buf_locale;
>
> public:
>
> virtual
> ~basic_streambuf()
> { }
># 210 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> locale
> pubimbue(const locale &__loc)
> {
> locale __tmp(this->getloc());
> this->imbue(__loc);
> _M_buf_locale = __loc;
> return __tmp;
> }
># 227 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> locale
> getloc() const
> { return _M_buf_locale; }
># 240 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> __streambuf_type*
> pubsetbuf(char_type* __s, streamsize __n)
> { return this->setbuf(__s, __n); }
>
> pos_type
> pubseekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekoff(__off, __way, __mode); }
>
> pos_type
> pubseekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekpos(__sp, __mode); }
>
> int
> pubsync() { return this->sync(); }
># 267 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> streamsize
> in_avail()
> {
> const streamsize __ret = this->egptr() - this->gptr();
> return __ret ? __ret : this->showmanyc();
> }
># 281 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> int_type
> snextc()
> {
> int_type __ret = traits_type::eof();
> if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
> __ret), true))
> __ret = this->sgetc();
> return __ret;
> }
># 299 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> int_type
> sbumpc()
> {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
> {
> __ret = traits_type::to_int_type(*this->gptr());
> this->gbump(1);
> }
> else
> __ret = this->uflow();
> return __ret;
> }
># 321 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> int_type
> sgetc()
> {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
> __ret = traits_type::to_int_type(*this->gptr());
> else
> __ret = this->underflow();
> return __ret;
> }
># 340 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> streamsize
> sgetn(char_type* __s, streamsize __n)
> { return this->xsgetn(__s, __n); }
># 354 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> int_type
> sputbackc(char_type __c)
> {
> int_type __ret;
> const bool __testpos = this->eback() < this->gptr();
> if (__builtin_expect(!__testpos ||
> !traits_type::eq(__c, this->gptr()[-1]), false))
> __ret = this->pbackfail(traits_type::to_int_type(__c));
> else
> {
> this->gbump(-1);
> __ret = traits_type::to_int_type(*this->gptr());
> }
> return __ret;
> }
># 379 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> int_type
> sungetc()
> {
> int_type __ret;
> if (__builtin_expect(this->eback() < this->gptr(), true))
> {
> this->gbump(-1);
> __ret = traits_type::to_int_type(*this->gptr());
> }
> else
> __ret = this->pbackfail();
> return __ret;
> }
># 406 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> int_type
> sputc(char_type __c)
> {
> int_type __ret;
> if (__builtin_expect(this->pptr() < this->epptr(), true))
> {
> *this->pptr() = __c;
> this->pbump(1);
> __ret = traits_type::to_int_type(__c);
> }
> else
> __ret = this->overflow(traits_type::to_int_type(__c));
> return __ret;
> }
># 432 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> streamsize
> sputn(const char_type* __s, streamsize __n)
> { return this->xsputn(__s, __n); }
>
> protected:
># 446 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> basic_streambuf()
> : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
> _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
> _M_buf_locale(locale())
> { }
># 464 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> char_type*
> eback() const { return _M_in_beg; }
>
> char_type*
> gptr() const { return _M_in_cur; }
>
> char_type*
> egptr() const { return _M_in_end; }
># 480 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> void
> gbump(int __n) { _M_in_cur += __n; }
># 491 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> void
> setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
> {
> _M_in_beg = __gbeg;
> _M_in_cur = __gnext;
> _M_in_end = __gend;
> }
># 511 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> char_type*
> pbase() const { return _M_out_beg; }
>
> char_type*
> pptr() const { return _M_out_cur; }
>
> char_type*
> epptr() const { return _M_out_end; }
># 527 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> void
> pbump(int __n) { _M_out_cur += __n; }
># 537 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> void
> setp(char_type* __pbeg, char_type* __pend)
> {
> _M_out_beg = _M_out_cur = __pbeg;
> _M_out_end = __pend;
> }
># 558 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual void
> imbue(const locale&)
> { }
># 573 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual basic_streambuf<char_type,_Traits>*
> setbuf(char_type*, streamsize)
> { return this; }
># 584 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual pos_type
> seekoff(off_type, ios_base::seekdir,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 596 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual pos_type
> seekpos(pos_type,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 609 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual int
> sync() { return 0; }
># 631 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual streamsize
> showmanyc() { return 0; }
># 647 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual streamsize
> xsgetn(char_type* __s, streamsize __n);
># 669 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual int_type
> underflow()
> { return traits_type::eof(); }
># 682 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual int_type
> uflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testeof = traits_type::eq_int_type(this->underflow(),
> __ret);
> if (!__testeof)
> {
> __ret = traits_type::to_int_type(*this->gptr());
> this->gbump(1);
> }
> return __ret;
> }
># 706 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual int_type
> pbackfail(int_type = traits_type::eof())
> { return traits_type::eof(); }
># 724 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual streamsize
> xsputn(const char_type* __s, streamsize __n);
># 749 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> virtual int_type
> overflow(int_type = traits_type::eof())
> { return traits_type::eof(); }
># 778 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 3
> private:
>
>
> basic_streambuf(const __streambuf_type& __sb)
> : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
> _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
> _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
> _M_buf_locale(__sb._M_buf_locale)
> { }
>
> __streambuf_type&
> operator=(const __streambuf_type&) { return *this; };
> };
>
>
> template<>
> streamsize
> __copy_streambufs(basic_streambuf<char>* __sbin,
> basic_streambuf<char>* __sbout);
>
> template<>
> streamsize
> __copy_streambufs(basic_streambuf<wchar_t>* __sbin,
> basic_streambuf<wchar_t>* __sbout);
>
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/streambuf.tcc" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/streambuf.tcc" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/streambuf.tcc" 3
>
>namespace std
>{
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsgetn(char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->egptr() - this->gptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(__s, this->gptr(), __len);
> __ret += __len;
> __s += __len;
> this->gbump(__len);
> }
>
> if (__ret < __n)
> {
> const int_type __c = this->uflow();
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> traits_type::assign(*__s++, traits_type::to_char_type(__c));
> ++__ret;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsputn(const char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->epptr() - this->pptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(this->pptr(), __s, __len);
> __ret += __len;
> __s += __len;
> this->pbump(__len);
> }
>
> if (__ret < __n)
> {
> int_type __c = this->overflow(traits_type::to_int_type(*__s));
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> ++__ret;
> ++__s;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout)
> {
> streamsize __ret = 0;
> typename _Traits::int_type __c = __sbin->sgetc();
> while (!_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __c = __sbout->sputc(_Traits::to_char_type(__c));
> if (_Traits::eq_int_type(__c, _Traits::eof()))
> break;
> ++__ret;
> __c = __sbin->snextc();
> }
> return __ret;
> }
>
>
>
>
>
> extern template class basic_streambuf<char>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<char>*, basic_streambuf<char>*);
>
>
> extern template class basic_streambuf<wchar_t>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<wchar_t>*, basic_streambuf<wchar_t>*);
>
>
>}
># 807 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/streambuf" 2 3
># 50 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/streambuf_iterator.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/streambuf_iterator.h" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/streambuf_iterator.h" 3
>
>
>
>
>
>
>namespace std
>{
>
>
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator
> : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
> _CharT*, _CharT&>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename _Traits::int_type int_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
>
> private:
>
>
>
>
>
>
>
> mutable streambuf_type* _M_sbuf;
> mutable int_type _M_c;
>
> public:
>
> istreambuf_iterator() throw()
> : _M_sbuf(0), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(istream_type& __s) throw()
> : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(streambuf_type* __s) throw()
> : _M_sbuf(__s), _M_c(traits_type::eof()) { }
>
>
>
>
> char_type
> operator*() const
> {
>
>
>
>
>
>
>
> return traits_type::to_char_type(_M_get());
> }
>
>
> istreambuf_iterator&
> operator++()
> {
> ;
>
>
> if (_M_sbuf)
> {
> _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> }
> return *this;
> }
>
>
> istreambuf_iterator
> operator++(int)
> {
> ;
>
>
>
> istreambuf_iterator __old = *this;
> if (_M_sbuf)
> {
> __old._M_c = _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> }
> return __old;
> }
>
>
>
>
>
> bool
> equal(const istreambuf_iterator& __b) const
> {
> const bool __thiseof = _M_at_eof();
> const bool __beof = __b._M_at_eof();
> return (__thiseof && __beof || (!__thiseof && !__beof));
> }
>
> private:
> int_type
> _M_get() const
> {
> const int_type __eof = traits_type::eof();
> int_type __ret = __eof;
> if (_M_sbuf)
> {
> if (!traits_type::eq_int_type(_M_c, __eof))
> __ret = _M_c;
> else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
> __eof))
> _M_c = __ret;
> else
> _M_sbuf = 0;
> }
> return __ret;
> }
>
> bool
> _M_at_eof() const
> {
> const int_type __eof = traits_type::eof();
> return traits_type::eq_int_type(_M_get(), __eof);
> }
> };
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return __a.equal(__b); }
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return !__a.equal(__b); }
>
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> private:
> streambuf_type* _M_sbuf;
> bool _M_failed;
>
> public:
>
> ostreambuf_iterator(ostream_type& __s) throw ()
> : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator(streambuf_type* __s) throw ()
> : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator&
> operator=(_CharT __c)
> {
> if (!_M_failed &&
> _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
> _M_failed = true;
> return *this;
> }
>
>
> ostreambuf_iterator&
> operator*()
> { return *this; }
>
>
> ostreambuf_iterator&
> operator++(int)
> { return *this; }
>
>
> ostreambuf_iterator&
> operator++()
> { return *this; }
>
>
> bool
> failed() const throw()
> { return _M_failed; }
>
> ostreambuf_iterator&
> _M_put(const _CharT* __ws, streamsize __len)
> {
> if (__builtin_expect(!_M_failed, true)
> && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
> false))
> _M_failed = true;
> return *this;
> }
> };
>}
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwctype" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwctype" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwctype" 3
>
>
>
>
># 1 "/usr/include/wctype.h" 1 3 4
># 35 "/usr/include/wctype.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h" 1 3 4
># 36 "/usr/include/wctype.h" 2 3 4
># 45 "/usr/include/wctype.h" 3 4
>
># 63 "/usr/include/wctype.h" 3 4
>
>
>
>typedef unsigned long int wctype_t;
>
># 85 "/usr/include/wctype.h" 3 4
>enum
>{
> __ISwupper = 0,
> __ISwlower = 1,
> __ISwalpha = 2,
> __ISwdigit = 3,
> __ISwxdigit = 4,
> __ISwspace = 5,
> __ISwprint = 6,
> __ISwgraph = 7,
> __ISwblank = 8,
> __ISwcntrl = 9,
> __ISwpunct = 10,
> __ISwalnum = 11,
>
> _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
> _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
> _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
> _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
> _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
> _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
> _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
> _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
> _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
> _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
> _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
> _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
>};
>
>
>
>extern "C" {
>
>
>
>
>
>
>
>
>extern int iswalnum (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswalpha (wint_t __wc) throw ();
>
>
>extern int iswcntrl (wint_t __wc) throw ();
>
>
>
>extern int iswdigit (wint_t __wc) throw ();
>
>
>
>extern int iswgraph (wint_t __wc) throw ();
>
>
>
>
>extern int iswlower (wint_t __wc) throw ();
>
>
>extern int iswprint (wint_t __wc) throw ();
>
>
>
>
>extern int iswpunct (wint_t __wc) throw ();
>
>
>
>
>extern int iswspace (wint_t __wc) throw ();
>
>
>
>
>extern int iswupper (wint_t __wc) throw ();
>
>
>
>
>extern int iswxdigit (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswblank (wint_t __wc) throw ();
># 185 "/usr/include/wctype.h" 3 4
>extern wctype_t wctype (__const char *__property) throw ();
>
>
>
>extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
>
>
>
>
>
>
>
>
>
>
>typedef __const __int32_t *wctrans_t;
>
>
>
>
>
>
>
>extern wint_t towlower (wint_t __wc) throw ();
>
>
>extern wint_t towupper (wint_t __wc) throw ();
>
>
>}
># 227 "/usr/include/wctype.h" 3 4
>extern "C" {
>
>
>
>
>extern wctrans_t wctrans (__const char *__property) throw ();
>
>
>extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
>
>
>
>
>
>
>
>
>extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>
>extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern wctype_t wctype_l (__const char *__property, __locale_t __locale)
> throw ();
>
>
>
>extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
> throw ();
>
>
>
>
>
>
>
>extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern wctrans_t wctrans_l (__const char *__property, __locale_t __locale)
> throw ();
>
>
>extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
> __locale_t __locale) throw ();
>
>
>
>}
># 54 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwctype" 2 3
># 79 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cwctype" 3
>namespace std
>{
> using ::wint_t;
>
> using ::wctype_t;
> using ::wctrans_t;
>
> using ::iswalnum;
> using ::iswalpha;
>
> using ::iswblank;
>
> using ::iswcntrl;
> using ::iswctype;
> using ::iswdigit;
> using ::iswgraph;
> using ::iswlower;
> using ::iswprint;
> using ::iswpunct;
> using ::iswspace;
> using ::iswupper;
> using ::iswxdigit;
> using ::towctrans;
> using ::towlower;
> using ::towupper;
> using ::wctrans;
> using ::wctype;
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 2 3
>
>
>
>
>namespace std
>{
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _Tv>
> void
> __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
> const __c_locale& __cloc);
>
>
> template<>
> void
> __convert_to_v(const char*, float&, ios_base::iostate&,
> const __c_locale&);
>
> template<>
> void
> __convert_to_v(const char*, double&, ios_base::iostate&,
> const __c_locale&);
>
> template<>
> void
> __convert_to_v(const char*, long double&, ios_base::iostate&,
> const __c_locale&);
>
>
>
> template<typename _CharT, typename _Traits>
> struct __pad
> {
> static void
> _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
> const _CharT* __olds, const streamsize __newlen,
> const streamsize __oldlen, const bool __num);
> };
>
>
>
>
>
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last);
>
>
>
>
> template<typename _CharT>
> inline
> ostreambuf_iterator<_CharT>
> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
> {
> __s._M_put(__ws, __len);
> return __s;
> }
>
>
> template<typename _CharT, typename _OutIter>
> inline
> _OutIter
> __write(_OutIter __s, const _CharT* __ws, int __len)
> {
> for (int __j = 0; __j < __len; __j++, ++__s)
> *__s = __ws[__j];
> return __s;
> }
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/ctype_base.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/ctype_base.h" 3
> struct ctype_base
> {
>
> typedef const int* __to_type;
>
>
>
> typedef unsigned short mask;
> static const mask upper = _ISupper;
> static const mask lower = _ISlower;
> static const mask alpha = _ISalpha;
> static const mask digit = _ISdigit;
> static const mask xdigit = _ISxdigit;
> static const mask space = _ISspace;
> static const mask print = _ISprint;
> static const mask graph = _ISalpha | _ISdigit | _ISpunct;
> static const mask cntrl = _IScntrl;
> static const mask punct = _ISpunct;
> static const mask alnum = _ISalpha | _ISdigit;
> };
># 133 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 2 3
># 144 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT>
> class __ctype_abstract_base : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef _CharT char_type;
># 162 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> bool
> is(mask __m, char_type __c) const
> { return this->do_is(__m, __c); }
># 179 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> is(const char_type *__lo, const char_type *__hi, mask *__vec) const
> { return this->do_is(__lo, __hi, __vec); }
># 195 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
> { return this->do_scan_is(__m, __lo, __hi); }
># 211 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
> { return this->do_scan_not(__m, __lo, __hi); }
># 225 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 240 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 254 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 269 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 286 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> { return this->do_widen(__c); }
># 305 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> { return this->do_widen(__lo, __hi, __to); }
># 324 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return this->do_narrow(__c, __dfault); }
># 346 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char *__to) const
> { return this->do_narrow(__lo, __hi, __dfault, __to); }
>
> protected:
> explicit
> __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
>
> virtual
> ~__ctype_abstract_base() { }
># 371 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const = 0;
># 390 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi,
> mask* __vec) const = 0;
># 409 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 428 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 446 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type) const = 0;
># 463 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const = 0;
># 479 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type) const = 0;
># 496 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const = 0;
># 515 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char) const = 0;
># 536 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi,
> char_type* __dest) const = 0;
># 558 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type, char __dfault) const = 0;
># 582 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __dest) const = 0;
> };
># 605 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT>
> class ctype : public __ctype_abstract_base<_CharT>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename __ctype_abstract_base<_CharT>::mask mask;
>
>
> static locale::id id;
>
> explicit
> ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
>
> protected:
> virtual
> ~ctype();
>
> virtual bool
> do_is(mask __m, char_type __c) const;
>
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
>
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
>
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
>
> virtual char_type
> do_toupper(char_type __c) const;
>
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
>
> virtual char_type
> do_tolower(char_type __c) const;
>
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
>
> virtual char_type
> do_widen(char __c) const;
>
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
>
> virtual char
> do_narrow(char_type, char __dfault) const;
>
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __dest) const;
> };
>
> template<typename _CharT>
> locale::id ctype<_CharT>::id;
># 674 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<>
> class ctype<char> : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef char char_type;
>
> protected:
>
> __c_locale _M_c_locale_ctype;
> bool _M_del;
> __to_type _M_toupper;
> __to_type _M_tolower;
> const mask* _M_table;
> mutable char _M_widen_ok;
> mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow_ok;
>
>
> public:
>
> static locale::id id;
>
> static const size_t table_size = 1 + static_cast<unsigned char>(-1);
># 711 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
># 724 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
> size_t __refs = 0);
># 737 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> inline bool
> is(mask __m, char __c) const;
># 752 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> inline const char*
> is(const char* __lo, const char* __hi, mask* __vec) const;
># 766 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> inline const char*
> scan_is(mask __m, const char* __lo, const char* __hi) const;
># 780 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> inline const char*
> scan_not(mask __m, const char* __lo, const char* __hi) const;
># 795 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 812 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 828 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 845 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 865 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> {
> if (_M_widen_ok)
> return _M_widen[static_cast<unsigned char>(__c)];
> this->_M_widen_init();
> return this->do_widen(__c);
> }
># 892 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> {
> if (_M_widen_ok == 1)
> {
> memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_widen_ok)
> _M_widen_init();
> return this->do_widen(__lo, __hi, __to);
> }
># 923 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> {
> if (_M_narrow[static_cast<unsigned char>(__c)])
> return _M_narrow[static_cast<unsigned char>(__c)];
> const char __t = do_narrow(__c, __dfault);
> if (__t != __dfault)
> _M_narrow[static_cast<unsigned char>(__c)] = __t;
> return __t;
> }
># 956 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> const char_type*
> narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char *__to) const
> {
> if (__builtin_expect(_M_narrow_ok == 1, true))
> {
> memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_narrow_ok)
> _M_narrow_init();
> return this->do_narrow(__lo, __hi, __dfault, __to);
> }
>
> protected:
>
>
> const mask*
> table() const throw()
> { return _M_table; }
>
>
> static const mask*
> classic_table() throw();
>
>
>
>
>
>
>
> virtual
> ~ctype();
># 1003 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type) const;
># 1020 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1036 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type) const;
># 1053 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1073 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const
> { return __c; }
># 1096 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const
> {
> memcpy(__dest, __lo, __hi - __lo);
> return __hi;
> }
># 1122 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char) const
> { return __c; }
># 1148 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char, char* __dest) const
> {
> memcpy(__dest, __lo, __hi - __lo);
> return __hi;
> }
>
> private:
>
> void _M_widen_init() const
> {
> char __tmp[sizeof(_M_widen)];
> for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
> __tmp[__i] = __i;
> do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);
>
> _M_widen_ok = 1;
>
> if (memcmp(__tmp, _M_widen, sizeof(_M_widen)))
> _M_widen_ok = 2;
> }
>
>
>
>
> void _M_narrow_init() const
> {
> char __tmp[sizeof(_M_narrow)];
> for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
> __tmp[__i] = __i;
> do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow);
>
> _M_narrow_ok = 1;
> if (memcmp(__tmp, _M_narrow, sizeof(_M_narrow)))
> _M_narrow_ok = 2;
> else
> {
>
>
> char __c;
> do_narrow(__tmp, __tmp + 1, 1, &__c);
> if (__c == 1)
> _M_narrow_ok = 2;
> }
> }
> };
>
> template<>
> const ctype<char>&
> use_facet<ctype<char> >(const locale& __loc);
># 1212 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<>
> class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
> {
> public:
>
>
> typedef wchar_t char_type;
> typedef wctype_t __wmask_type;
>
> protected:
> __c_locale _M_c_locale_ctype;
>
>
> bool _M_narrow_ok;
> char _M_narrow[128];
> wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
>
>
> mask _M_bit[16];
> __wmask_type _M_wmask[16];
>
> public:
>
>
> static locale::id id;
># 1245 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> ctype(size_t __refs = 0);
># 1256 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> __wmask_type
> _M_convert_to_wmask(const mask __m) const;
>
>
> virtual
> ~ctype();
># 1280 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const;
># 1299 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
># 1317 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
># 1335 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
># 1352 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type) const;
># 1369 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1385 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type) const;
># 1402 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1422 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char) const;
># 1444 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
># 1467 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type, char __dfault) const;
># 1493 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __dest) const;
>
>
> void
> _M_initialize_ctype();
> };
>
> template<>
> const ctype<wchar_t>&
> use_facet<ctype<wchar_t> >(const locale& __loc);
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/ctype_inline.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/ctype_inline.h" 3
> bool
> ctype<char>::
> is(mask __m, char __c) const
> { return _M_table[static_cast<unsigned char>(__c)] & __m; }
>
> const char*
> ctype<char>::
> is(const char* __low, const char* __high, mask* __vec) const
> {
> while (__low < __high)
> *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
> return __high;
> }
>
> const char*
> ctype<char>::
> scan_is(mask __m, const char* __low, const char* __high) const
> {
> while (__low < __high
> && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
> ++__low;
> return __low;
> }
>
> const char*
> ctype<char>::
> scan_not(mask __m, const char* __low, const char* __high) const
> {
> while (__low < __high
> && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
> ++__low;
> return __low;
> }
># 1509 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 2 3
>
>
> template<typename _CharT>
> class ctype_byname : public ctype<_CharT>
> {
> public:
> typedef _CharT char_type;
>
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname() { };
> };
>
>
> template<>
> ctype_byname<char>::ctype_byname(const char*, size_t refs);
>
> template<>
> ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 1 3
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
> 
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
>
>
> class codecvt_base
> {
> public:
> enum result
> {
> ok,
> partial,
> error,
> noconv
> };
> };
># 69 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
> template<typename _InternT, typename _ExternT, typename _StateT>
> class __codecvt_abstract_base
> : public locale::facet, public codecvt_base
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef _StateT state_type;
># 117 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
> result
> out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> {
> return this->do_out(__state, __from, __from_end, __from_next,
> __to, __to_end, __to_next);
> }
># 156 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
> result
> unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> { return this->do_unshift(__state, __to,__to_end,__to_next); }
># 197 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
> result
> in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const
> {
> return this->do_in(__state, __from, __from_end, __from_next,
> __to, __to_end, __to_next);
> }
>
> int
> encoding() const throw()
> { return this->do_encoding(); }
>
> bool
> always_noconv() const throw()
> { return this->do_always_noconv(); }
>
> int
> length(state_type& __state, const extern_type* __from,
> const extern_type* __end, size_t __max) const
> { return this->do_length(__state, __from, __end, __max); }
>
> int
> max_length() const throw()
> { return this->do_max_length(); }
>
> protected:
> explicit
> __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
>
> virtual
> ~__codecvt_abstract_base() { }
># 238 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/codecvt.h" 3
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const = 0;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const = 0;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const = 0;
>
> virtual int
> do_encoding() const throw() = 0;
>
> virtual bool
> do_always_noconv() const throw() = 0;
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const = 0;
>
> virtual int
> do_max_length() const throw() = 0;
> };
>
>
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt
> : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef _StateT state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0)
> : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt() { }
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> locale::id codecvt<_InternT, _ExternT, _StateT>::id;
>
>
> template<>
> class codecvt<char, char, mbstate_t>
> : public __codecvt_abstract_base<char, char, mbstate_t>
> {
> public:
>
> typedef char intern_type;
> typedef char extern_type;
> typedef mbstate_t state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0);
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt();
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
>
>
> template<>
> class codecvt<wchar_t, char, mbstate_t>
> : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
> {
> public:
>
> typedef wchar_t intern_type;
> typedef char extern_type;
> typedef mbstate_t state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0);
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt();
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state,
> const extern_type* __from, const extern_type* __from_end,
> const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual
> int do_encoding() const throw();
>
> virtual
> bool do_always_noconv() const throw();
>
> virtual
> int do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
>
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
> {
> public:
> explicit
> codecvt_byname(const char* __s, size_t __refs = 0)
> : codecvt<_InternT, _ExternT, _StateT>(__refs)
> {
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
> this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
> }
> }
>
> protected:
> virtual
> ~codecvt_byname() { }
> };
># 1534 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 2 3
>
>
> class __num_base
> {
> public:
>
>
> enum
> {
> _S_ominus,
> _S_oplus,
> _S_ox,
> _S_oX,
> _S_odigits,
> _S_odigits_end = _S_odigits + 16,
> _S_oudigits = _S_odigits_end,
> _S_oudigits_end = _S_oudigits + 16,
> _S_oe = _S_odigits + 14,
> _S_oE = _S_oudigits + 14,
> _S_oend = _S_oudigits_end
> };
>
>
>
>
>
>
> static const char* _S_atoms_out;
>
>
>
> static const char* _S_atoms_in;
>
> enum
> {
> _S_iminus,
> _S_iplus,
> _S_ix,
> _S_iX,
> _S_izero,
> _S_ie = _S_izero + 14,
> _S_iE = _S_izero + 20,
> _S_iend = 26
> };
>
>
>
> static void
> _S_format_float(const ios_base& __io, char* __fptr, char __mod);
> };
>
> template<typename _CharT>
> struct __numpunct_cache : public locale::facet
> {
> const char* _M_grouping;
> size_t _M_grouping_size;
> bool _M_use_grouping;
> const _CharT* _M_truename;
> size_t _M_truename_size;
> const _CharT* _M_falsename;
> size_t _M_falsename_size;
> _CharT _M_decimal_point;
> _CharT _M_thousands_sep;
>
>
>
>
>
> _CharT _M_atoms_out[__num_base::_S_oend];
>
>
>
>
>
> _CharT _M_atoms_in[__num_base::_S_iend];
>
> bool _M_allocated;
>
> __numpunct_cache(size_t __refs = 0) : facet(__refs),
> _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
> _M_truename(__null), _M_truename_size(0), _M_falsename(__null),
> _M_falsename_size(0), _M_decimal_point(_CharT()),
> _M_thousands_sep(_CharT()), _M_allocated(false)
> { }
>
> ~__numpunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __numpunct_cache&
> operator=(const __numpunct_cache&);
>
> explicit
> __numpunct_cache(const __numpunct_cache&);
> };
>
> template<typename _CharT>
> __numpunct_cache<_CharT>::~__numpunct_cache()
> {
> if (_M_allocated)
> {
> delete [] _M_grouping;
> delete [] _M_truename;
> delete [] _M_falsename;
> }
> }
># 1656 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT>
> class numpunct : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> typedef __numpunct_cache<_CharT> __cache_type;
>
> protected:
> __cache_type* _M_data;
>
> public:
>
> static locale::id id;
>
>
>
>
>
>
> explicit
> numpunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
> { _M_initialize_numpunct(); }
># 1693 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> numpunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_numpunct(); }
># 1707 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> numpunct(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_data(__null)
> { _M_initialize_numpunct(__cloc); }
># 1721 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 1734 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 1765 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 1778 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> truename() const
> { return this->do_truename(); }
># 1791 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> falsename() const
> { return this->do_falsename(); }
>
> protected:
>
> virtual
> ~numpunct();
># 1808 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 1820 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 1833 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 1846 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_truename() const
> { return _M_data->_M_truename; }
># 1859 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_falsename() const
> { return _M_data->_M_falsename; }
>
>
> void
> _M_initialize_numpunct(__c_locale __cloc = __null);
> };
>
> template<typename _CharT>
> locale::id numpunct<_CharT>::id;
>
> template<>
> numpunct<char>::~numpunct();
>
> template<>
> void
> numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
>
>
> template<>
> numpunct<wchar_t>::~numpunct();
>
> template<>
> void
> numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
>
>
>
> template<typename _CharT>
> class numpunct_byname : public numpunct<_CharT>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> explicit
> numpunct_byname(const char* __s, size_t __refs = 0)
> : numpunct<_CharT>(__refs)
> {
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> __c_locale __tmp;
> this->_S_create_c_locale(__tmp, __s);
> this->_M_initialize_numpunct(__tmp);
> this->_S_destroy_c_locale(__tmp);
> }
> }
>
> protected:
> virtual
> ~numpunct_byname() { }
> };
>
>
># 1926 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class num_get : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
>
>
> static locale::id id;
># 1947 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> num_get(size_t __refs = 0) : facet(__refs) { }
># 1973 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, bool& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 2009 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned short& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned int& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 2068 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, float& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, double& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long double& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 2110 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, void*& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> protected:
>
> virtual ~num_get() { }
>
> iter_type
> _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
> string& __xtrc) const;
>
> template<typename _ValueT>
> iter_type
> _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
> _ValueT& __v) const;
># 2143 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned short&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned int&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned long&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> long long&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned long long&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> float&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> double&) const;
>
>
>
>
>
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> long double&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> void*&) const;
># 2202 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> };
>
> template<typename _CharT, typename _InIter>
> locale::id num_get<_CharT, _InIter>::id;
># 2219 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class num_put : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
>
>
> static locale::id id;
># 2240 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> num_put(size_t __refs = 0) : facet(__refs) { }
># 2258 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
> { return this->do_put(__s, __f, __fill, __v); }
># 2300 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> unsigned long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> unsigned long long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
># 2363 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> long double __v) const
> { return this->do_put(__s, __f, __fill, __v); }
># 2388 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> const void* __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> protected:
> template<typename _ValueT>
> iter_type
> _M_insert_float(iter_type, ios_base& __io, char_type __fill,
> char __mod, _ValueT __v) const;
>
> void
> _M_group_float(const char* __grouping, size_t __grouping_size,
> char_type __sep, const char_type* __p, char_type* __new,
> char_type* __cs, int& __len) const;
>
> template<typename _ValueT>
> iter_type
> _M_insert_int(iter_type, ios_base& __io, char_type __fill,
> _ValueT __v) const;
>
> void
> _M_group_int(const char* __grouping, size_t __grouping_size,
> char_type __sep, ios_base& __io, char_type* __new,
> char_type* __cs, int& __len) const;
>
> void
> _M_pad(char_type __fill, streamsize __w, ios_base& __io,
> char_type* __new, const char_type* __cs, int& __len) const;
>
>
> virtual
> ~num_put() { };
># 2436 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, long __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, long long __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, double __v) const;
>
>
>
>
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
>
>
>
>
>
>
>
> };
>
> template <typename _CharT, typename _OutIter>
> locale::id num_put<_CharT, _OutIter>::id;
>
>
># 2493 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT>
> class collate : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> protected:
>
>
> __c_locale _M_c_locale_collate;
>
> public:
>
> static locale::id id;
># 2520 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> collate(size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
> { }
># 2534 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> collate(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
> { }
># 2551 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> int
> compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const
> { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
># 2570 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> transform(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_transform(__lo, __hi); }
># 2584 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> long
> hash(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_hash(__lo, __hi); }
>
>
> int
> _M_compare(const _CharT*, const _CharT*) const;
>
> size_t
> _M_transform(_CharT*, const _CharT*, size_t) const;
>
> protected:
>
> virtual
> ~collate()
> { _S_destroy_c_locale(_M_c_locale_collate); }
># 2613 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual int
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const;
># 2629 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_transform(const _CharT* __lo, const _CharT* __hi) const;
># 2642 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual long
> do_hash(const _CharT* __lo, const _CharT* __hi) const;
> };
>
> template<typename _CharT>
> locale::id collate<_CharT>::id;
>
>
> template<>
> int
> collate<char>::_M_compare(const char*, const char*) const;
>
> template<>
> size_t
> collate<char>::_M_transform(char*, const char*, size_t) const;
>
>
> template<>
> int
> collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;
>
> template<>
> size_t
> collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;
>
>
>
> template<typename _CharT>
> class collate_byname : public collate<_CharT>
> {
> public:
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> explicit
> collate_byname(const char* __s, size_t __refs = 0)
> : collate<_CharT>(__refs)
> {
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_collate);
> this->_S_create_c_locale(this->_M_c_locale_collate, __s);
> }
> }
>
> protected:
> virtual
> ~collate_byname() { }
> };
># 2702 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> class time_base
> {
> public:
> enum dateorder { no_order, dmy, mdy, ymd, ydm };
> };
>
> template<typename _CharT>
> struct __timepunct_cache : public locale::facet
> {
>
> static const _CharT* _S_timezones[14];
>
> const _CharT* _M_date_format;
> const _CharT* _M_date_era_format;
> const _CharT* _M_time_format;
> const _CharT* _M_time_era_format;
> const _CharT* _M_date_time_format;
> const _CharT* _M_date_time_era_format;
> const _CharT* _M_am;
> const _CharT* _M_pm;
> const _CharT* _M_am_pm_format;
>
>
> const _CharT* _M_day1;
> const _CharT* _M_day2;
> const _CharT* _M_day3;
> const _CharT* _M_day4;
> const _CharT* _M_day5;
> const _CharT* _M_day6;
> const _CharT* _M_day7;
>
>
> const _CharT* _M_aday1;
> const _CharT* _M_aday2;
> const _CharT* _M_aday3;
> const _CharT* _M_aday4;
> const _CharT* _M_aday5;
> const _CharT* _M_aday6;
> const _CharT* _M_aday7;
>
>
> const _CharT* _M_month01;
> const _CharT* _M_month02;
> const _CharT* _M_month03;
> const _CharT* _M_month04;
> const _CharT* _M_month05;
> const _CharT* _M_month06;
> const _CharT* _M_month07;
> const _CharT* _M_month08;
> const _CharT* _M_month09;
> const _CharT* _M_month10;
> const _CharT* _M_month11;
> const _CharT* _M_month12;
>
>
> const _CharT* _M_amonth01;
> const _CharT* _M_amonth02;
> const _CharT* _M_amonth03;
> const _CharT* _M_amonth04;
> const _CharT* _M_amonth05;
> const _CharT* _M_amonth06;
> const _CharT* _M_amonth07;
> const _CharT* _M_amonth08;
> const _CharT* _M_amonth09;
> const _CharT* _M_amonth10;
> const _CharT* _M_amonth11;
> const _CharT* _M_amonth12;
>
> bool _M_allocated;
>
> __timepunct_cache(size_t __refs = 0) : facet(__refs),
> _M_date_format(__null), _M_date_era_format(__null), _M_time_format(__null),
> _M_time_era_format(__null), _M_date_time_format(__null),
> _M_date_time_era_format(__null), _M_am(__null), _M_pm(__null),
> _M_am_pm_format(__null), _M_day1(__null), _M_day2(__null), _M_day3(__null),
> _M_day4(__null), _M_day5(__null), _M_day6(__null), _M_day7(__null),
> _M_aday1(__null), _M_aday2(__null), _M_aday3(__null), _M_aday4(__null),
> _M_aday5(__null), _M_aday6(__null), _M_aday7(__null), _M_month01(__null),
> _M_month02(__null), _M_month03(__null), _M_month04(__null), _M_month05(__null),
> _M_month06(__null), _M_month07(__null), _M_month08(__null), _M_month09(__null),
> _M_month10(__null), _M_month11(__null), _M_month12(__null), _M_amonth01(__null),
> _M_amonth02(__null), _M_amonth03(__null), _M_amonth04(__null),
> _M_amonth05(__null), _M_amonth06(__null), _M_amonth07(__null),
> _M_amonth08(__null), _M_amonth09(__null), _M_amonth10(__null),
> _M_amonth11(__null), _M_amonth12(__null), _M_allocated(false)
> { }
>
> ~__timepunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __timepunct_cache&
> operator=(const __timepunct_cache&);
>
> explicit
> __timepunct_cache(const __timepunct_cache&);
> };
>
> template<typename _CharT>
> __timepunct_cache<_CharT>::~__timepunct_cache()
> {
> if (_M_allocated)
> {
>
> }
> }
>
>
> template<>
> const char*
> __timepunct_cache<char>::_S_timezones[14];
>
>
> template<>
> const wchar_t*
> __timepunct_cache<wchar_t>::_S_timezones[14];
>
>
>
> template<typename _CharT>
> const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
>
> template<typename _CharT>
> class __timepunct : public locale::facet
> {
> public:
>
> typedef _CharT __char_type;
> typedef basic_string<_CharT> __string_type;
> typedef __timepunct_cache<_CharT> __cache_type;
>
> protected:
> __cache_type* _M_data;
> __c_locale _M_c_locale_timepunct;
> const char* _M_name_timepunct;
>
> public:
>
> static locale::id id;
>
> explicit
> __timepunct(size_t __refs = 0);
>
> explicit
> __timepunct(__cache_type* __cache, size_t __refs = 0);
># 2860 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
>
>
>
> void
> _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
> const tm* __tm) const;
>
> void
> _M_date_formats(const _CharT** __date) const
> {
>
> __date[0] = _M_data->_M_date_format;
> __date[1] = _M_data->_M_date_era_format;
> }
>
> void
> _M_time_formats(const _CharT** __time) const
> {
>
> __time[0] = _M_data->_M_time_format;
> __time[1] = _M_data->_M_time_era_format;
> }
>
> void
> _M_date_time_formats(const _CharT** __dt) const
> {
>
> __dt[0] = _M_data->_M_date_time_format;
> __dt[1] = _M_data->_M_date_time_era_format;
> }
>
> void
> _M_am_pm_format(const _CharT* __ampm) const
> { __ampm = _M_data->_M_am_pm_format; }
>
> void
> _M_am_pm(const _CharT** __ampm) const
> {
> __ampm[0] = _M_data->_M_am;
> __ampm[1] = _M_data->_M_pm;
> }
>
> void
> _M_days(const _CharT** __days) const
> {
> __days[0] = _M_data->_M_day1;
> __days[1] = _M_data->_M_day2;
> __days[2] = _M_data->_M_day3;
> __days[3] = _M_data->_M_day4;
> __days[4] = _M_data->_M_day5;
> __days[5] = _M_data->_M_day6;
> __days[6] = _M_data->_M_day7;
> }
>
> void
> _M_days_abbreviated(const _CharT** __days) const
> {
> __days[0] = _M_data->_M_aday1;
> __days[1] = _M_data->_M_aday2;
> __days[2] = _M_data->_M_aday3;
> __days[3] = _M_data->_M_aday4;
> __days[4] = _M_data->_M_aday5;
> __days[5] = _M_data->_M_aday6;
> __days[6] = _M_data->_M_aday7;
> }
>
> void
> _M_months(const _CharT** __months) const
> {
> __months[0] = _M_data->_M_month01;
> __months[1] = _M_data->_M_month02;
> __months[2] = _M_data->_M_month03;
> __months[3] = _M_data->_M_month04;
> __months[4] = _M_data->_M_month05;
> __months[5] = _M_data->_M_month06;
> __months[6] = _M_data->_M_month07;
> __months[7] = _M_data->_M_month08;
> __months[8] = _M_data->_M_month09;
> __months[9] = _M_data->_M_month10;
> __months[10] = _M_data->_M_month11;
> __months[11] = _M_data->_M_month12;
> }
>
> void
> _M_months_abbreviated(const _CharT** __months) const
> {
> __months[0] = _M_data->_M_amonth01;
> __months[1] = _M_data->_M_amonth02;
> __months[2] = _M_data->_M_amonth03;
> __months[3] = _M_data->_M_amonth04;
> __months[4] = _M_data->_M_amonth05;
> __months[5] = _M_data->_M_amonth06;
> __months[6] = _M_data->_M_amonth07;
> __months[7] = _M_data->_M_amonth08;
> __months[8] = _M_data->_M_amonth09;
> __months[9] = _M_data->_M_amonth10;
> __months[10] = _M_data->_M_amonth11;
> __months[11] = _M_data->_M_amonth12;
> }
>
> protected:
> virtual
> ~__timepunct();
>
>
> void
> _M_initialize_timepunct(__c_locale __cloc = __null);
> };
>
> template<typename _CharT>
> locale::id __timepunct<_CharT>::id;
>
>
> template<>
> void
> __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
>
> template<>
> void
> __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;
>
>
> template<>
> void
> __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
>
> template<>
> void
> __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
> const tm*) const;
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/time_members.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/time_members.h" 3
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(size_t __refs)
> : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
> _M_name_timepunct(_S_get_c_name())
> { _M_initialize_timepunct(); }
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
> : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(__null),
> _M_name_timepunct(_S_get_c_name())
> { _M_initialize_timepunct(); }
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
> size_t __refs)
> : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
> _M_name_timepunct(__null)
> {
> const size_t __len = std::strlen(__s) + 1;
> char* __tmp = new char[__len];
> std::memcpy(__tmp, __s, __len);
> _M_name_timepunct = __tmp;
>
> try
> { _M_initialize_timepunct(__cloc); }
> catch(...)
> {
> delete [] _M_name_timepunct;
> throw;
> }
> }
>
> template<typename _CharT>
> __timepunct<_CharT>::~__timepunct()
> {
> if (_M_name_timepunct != _S_get_c_name())
> delete [] _M_name_timepunct;
> delete _M_data;
> _S_destroy_c_locale(_M_c_locale_timepunct);
> }
># 2996 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 2 3
># 3009 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class time_get : public locale::facet, public time_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
> typedef basic_string<_CharT> __string_type;
>
>
> static locale::id id;
># 3031 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> time_get(size_t __refs = 0)
> : facet (__refs) { }
># 3048 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> dateorder
> date_order() const
> { return this->do_date_order(); }
># 3072 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_time(__beg, __end, __io, __err, __tm); }
># 3097 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_date(__beg, __end, __io, __err, __tm); }
># 3125 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
># 3154 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
># 3180 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_year(__beg, __end, __io, __err, __tm); }
>
> protected:
>
> virtual
> ~time_get() { }
># 3200 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual dateorder
> do_date_order() const;
># 3218 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
># 3237 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
># 3256 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
> ios_base::iostate& __err, tm* __tm) const;
># 3275 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
> ios_base::iostate& __err, tm* __tm) const;
># 3294 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
>
>
> iter_type
> _M_extract_num(iter_type __beg, iter_type __end, int& __member,
> int __min, int __max, size_t __len,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
>
> iter_type
> _M_extract_name(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
> iter_type
> _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm,
> const _CharT* __format) const;
> };
>
> template<typename _CharT, typename _InIter>
> locale::id time_get<_CharT, _InIter>::id;
>
>
> template<typename _CharT, typename _InIter>
> class time_get_byname : public time_get<_CharT, _InIter>
> {
> public:
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
> explicit
> time_get_byname(const char*, size_t __refs = 0)
> : time_get<_CharT, _InIter>(__refs) { }
>
> protected:
> virtual
> ~time_get_byname() { }
> };
># 3350 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class time_put : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
>
>
> static locale::id id;
># 3371 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> time_put(size_t __refs = 0)
> : facet(__refs) { }
># 3390 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> const _CharT* __beg, const _CharT* __end) const;
># 3410 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> const tm* __tm, char __format, char __mod = 0) const
> { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
>
> protected:
>
> virtual
> ~time_put()
> { }
># 3437 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> char __format, char __mod) const;
> };
>
> template<typename _CharT, typename _OutIter>
> locale::id time_put<_CharT, _OutIter>::id;
>
>
> template<typename _CharT, typename _OutIter>
> class time_put_byname : public time_put<_CharT, _OutIter>
> {
> public:
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
> explicit
> time_put_byname(const char*, size_t __refs = 0)
> : time_put<_CharT, _OutIter>(__refs)
> { };
>
> protected:
> virtual
> ~time_put_byname() { }
> };
># 3475 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> class money_base
> {
> public:
> enum part { none, space, symbol, sign, value };
> struct pattern { char field[4]; };
>
> static const pattern _S_default_pattern;
>
> enum
> {
> _S_minus,
> _S_zero,
> _S_end = 11
> };
>
>
>
> static const char* _S_atoms;
>
>
>
> static pattern
> _S_construct_pattern(char __precedes, char __space, char __posn);
> };
>
> template<typename _CharT, bool _Intl>
> struct __moneypunct_cache : public locale::facet
> {
> const char* _M_grouping;
> size_t _M_grouping_size;
> bool _M_use_grouping;
> _CharT _M_decimal_point;
> _CharT _M_thousands_sep;
> const _CharT* _M_curr_symbol;
> size_t _M_curr_symbol_size;
> const _CharT* _M_positive_sign;
> size_t _M_positive_sign_size;
> const _CharT* _M_negative_sign;
> size_t _M_negative_sign_size;
> int _M_frac_digits;
> money_base::pattern _M_pos_format;
> money_base::pattern _M_neg_format;
>
>
>
>
> _CharT _M_atoms[money_base::_S_end];
>
> bool _M_allocated;
>
> __moneypunct_cache(size_t __refs = 0) : facet(__refs),
> _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
> _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
> _M_curr_symbol(__null), _M_curr_symbol_size(0),
> _M_positive_sign(__null), _M_positive_sign_size(0),
> _M_negative_sign(__null), _M_negative_sign_size(0),
> _M_frac_digits(0),
> _M_pos_format(money_base::pattern()),
> _M_neg_format(money_base::pattern()), _M_allocated(false)
> { }
>
> ~__moneypunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __moneypunct_cache&
> operator=(const __moneypunct_cache&);
>
> explicit
> __moneypunct_cache(const __moneypunct_cache&);
> };
>
> template<typename _CharT, bool _Intl>
> __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
> {
> if (_M_allocated)
> {
> delete [] _M_grouping;
> delete [] _M_curr_symbol;
> delete [] _M_positive_sign;
> delete [] _M_negative_sign;
> }
> }
>
>
>
>
>
>
>
> template<typename _CharT, bool _Intl>
> class moneypunct : public locale::facet, public money_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> private:
> __cache_type* _M_data;
>
> public:
>
>
> static const bool intl = _Intl;
>
> static locale::id id;
># 3596 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
> { _M_initialize_moneypunct(); }
># 3608 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> moneypunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_moneypunct(); }
># 3623 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
> : facet(__refs), _M_data(__null)
> { _M_initialize_moneypunct(__cloc, __s); }
># 3637 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 3650 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 3679 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 3692 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> curr_symbol() const
> { return this->do_curr_symbol(); }
># 3709 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> positive_sign() const
> { return this->do_positive_sign(); }
># 3726 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> negative_sign() const
> { return this->do_negative_sign(); }
># 3742 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> int
> frac_digits() const
> { return this->do_frac_digits(); }
># 3777 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> pattern
> pos_format() const
> { return this->do_pos_format(); }
>
> pattern
> neg_format() const
> { return this->do_neg_format(); }
>
>
> protected:
>
> virtual
> ~moneypunct();
># 3799 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 3811 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 3824 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 3837 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_curr_symbol() const
> { return _M_data->_M_curr_symbol; }
># 3850 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_positive_sign() const
> { return _M_data->_M_positive_sign; }
># 3863 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_negative_sign() const
> { return _M_data->_M_negative_sign; }
># 3877 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual int
> do_frac_digits() const
> { return _M_data->_M_frac_digits; }
># 3891 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual pattern
> do_pos_format() const
> { return _M_data->_M_pos_format; }
># 3905 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual pattern
> do_neg_format() const
> { return _M_data->_M_neg_format; }
>
>
> void
> _M_initialize_moneypunct(__c_locale __cloc = __null,
> const char* __name = __null);
> };
>
> template<typename _CharT, bool _Intl>
> locale::id moneypunct<_CharT, _Intl>::id;
>
> template<typename _CharT, bool _Intl>
> const bool moneypunct<_CharT, _Intl>::intl;
>
> template<>
> moneypunct<char, true>::~moneypunct();
>
> template<>
> moneypunct<char, false>::~moneypunct();
>
> template<>
> void
> moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
>
> template<>
> void
> moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
>
>
> template<>
> moneypunct<wchar_t, true>::~moneypunct();
>
> template<>
> moneypunct<wchar_t, false>::~moneypunct();
>
> template<>
> void
> moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
> const char*);
>
> template<>
> void
> moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
> const char*);
>
>
>
> template<typename _CharT, bool _Intl>
> class moneypunct_byname : public moneypunct<_CharT, _Intl>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> static const bool intl = _Intl;
>
> explicit
> moneypunct_byname(const char* __s, size_t __refs = 0)
> : moneypunct<_CharT, _Intl>(__refs)
> {
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> __c_locale __tmp;
> this->_S_create_c_locale(__tmp, __s);
> this->_M_initialize_moneypunct(__tmp);
> this->_S_destroy_c_locale(__tmp);
> }
> }
>
> protected:
> virtual
> ~moneypunct_byname() { }
> };
>
> template<typename _CharT, bool _Intl>
> const bool moneypunct_byname<_CharT, _Intl>::intl;
>
>
># 3997 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class money_get : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
> typedef basic_string<_CharT> string_type;
>
>
>
> static locale::id id;
># 4019 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> money_get(size_t __refs = 0) : facet(__refs) { }
># 4049 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const
> { return this->do_get(__s, __end, __intl, __io, __err, __units); }
># 4079 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const
> { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
>
> protected:
>
> virtual
> ~money_get() { }
># 4102 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const;
># 4114 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const;
># 4125 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<bool _Intl>
> iter_type
> _M_extract(iter_type __s, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, string& __digits) const;
> };
>
> template<typename _CharT, typename _InIter>
> locale::id money_get<_CharT, _InIter>::id;
># 4146 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class money_put : public locale::facet
> {
> public:
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
> typedef basic_string<_CharT> string_type;
>
>
>
> static locale::id id;
># 4167 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> money_put(size_t __refs = 0) : facet(__refs) { }
># 4187 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, bool __intl, ios_base& __io,
> char_type __fill, long double __units) const
> { return this->do_put(__s, __intl, __io, __fill, __units); }
># 4209 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, bool __intl, ios_base& __io,
> char_type __fill, const string_type& __digits) const
> { return this->do_put(__s, __intl, __io, __fill, __digits); }
>
> protected:
>
> virtual
> ~money_put() { }
># 4243 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> long double __units) const;
># 4266 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> const string_type& __digits) const;
># 4277 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<bool _Intl>
> iter_type
> _M_insert(iter_type __s, ios_base& __io, char_type __fill,
> const string_type& __digits) const;
> };
>
> template<typename _CharT, typename _OutIter>
> locale::id money_put<_CharT, _OutIter>::id;
>
>
>
>
>
>
> struct messages_base
> {
> typedef int catalog;
> };
># 4316 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT>
> class messages : public locale::facet, public messages_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> protected:
>
>
> __c_locale _M_c_locale_messages;
> const char* _M_name_messages;
>
> public:
>
> static locale::id id;
># 4344 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> messages(size_t __refs = 0);
># 4358 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> explicit
> messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
># 4371 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> catalog
> open(const basic_string<char>& __s, const locale& __loc) const
> { return this->do_open(__s, __loc); }
># 4389 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> catalog
> open(const basic_string<char>&, const locale&, const char*) const;
># 4407 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> string_type
> get(catalog __c, int __set, int __msgid, const string_type& __s) const
> { return this->do_get(__c, __set, __msgid, __s); }
># 4418 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> void
> close(catalog __c) const
> { return this->do_close(__c); }
>
> protected:
>
> virtual
> ~messages();
># 4438 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual catalog
> do_open(const basic_string<char>&, const locale&) const;
># 4457 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> virtual string_type
> do_get(catalog, int, int, const string_type& __dfault) const;
>
>
>
>
>
>
> virtual void
> do_close(catalog) const;
>
>
> char*
> _M_convert_to_char(const string_type& __msg) const
> {
>
> return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
> }
>
>
> string_type
> _M_convert_from_char(char*) const
> {
># 4514 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> return string_type();
> }
> };
>
> template<typename _CharT>
> locale::id messages<_CharT>::id;
>
>
> template<>
> string
> messages<char>::do_get(catalog, int, int, const string&) const;
>
>
> template<>
> wstring
> messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
>
>
>
> template<typename _CharT>
> class messages_byname : public messages<_CharT>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> explicit
> messages_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~messages_byname()
> { }
> };
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/messages_members.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/i386-redhat-linux/bits/messages_members.h" 3
> template<typename _CharT>
> messages<_CharT>::messages(size_t __refs)
> : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
> _M_name_messages(_S_get_c_name())
> { }
>
> template<typename _CharT>
> messages<_CharT>::messages(__c_locale __cloc, const char* __s,
> size_t __refs)
> : facet(__refs), _M_c_locale_messages(__null), _M_name_messages(__null)
> {
> const size_t __len = std::strlen(__s) + 1;
> char* __tmp = new char[__len];
> std::memcpy(__tmp, __s, __len);
> _M_name_messages = __tmp;
>
>
> _M_c_locale_messages = _S_clone_c_locale(__cloc);
> }
>
> template<typename _CharT>
> typename messages<_CharT>::catalog
> messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
> const char* __dir) const
> {
> bindtextdomain(__s.c_str(), __dir);
> return this->do_open(__s, __loc);
> }
>
>
> template<typename _CharT>
> messages<_CharT>::~messages()
> {
> if (_M_name_messages != _S_get_c_name())
> delete [] _M_name_messages;
> _S_destroy_c_locale(_M_c_locale_messages);
> }
>
> template<typename _CharT>
> typename messages<_CharT>::catalog
> messages<_CharT>::do_open(const basic_string<char>& __s,
> const locale&) const
> {
>
>
> textdomain(__s.c_str());
> return 0;
> }
>
> template<typename _CharT>
> void
> messages<_CharT>::do_close(catalog) const
> { }
>
>
> template<typename _CharT>
> messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
> : messages<_CharT>(__refs)
> {
> if (this->_M_name_messages != locale::facet::_S_get_c_name())
> delete [] this->_M_name_messages;
> char* __tmp = new char[std::strlen(__s) + 1];
> std::strcpy(__tmp, __s);
> this->_M_name_messages = __tmp;
>
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_messages);
> this->_S_create_c_locale(this->_M_c_locale_messages, __s);
> }
> }
># 4551 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 2 3
># 4559 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.h" 3
> template<typename _CharT>
> inline bool
> isspace(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
>
>
> template<typename _CharT>
> inline bool
> isprint(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
>
>
> template<typename _CharT>
> inline bool
> iscntrl(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
>
>
> template<typename _CharT>
> inline bool
> isupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
>
>
> template<typename _CharT>
> inline bool
> islower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalpha(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
>
>
> template<typename _CharT>
> inline bool
> isdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
>
>
> template<typename _CharT>
> inline bool
> ispunct(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
>
>
> template<typename _CharT>
> inline bool
> isxdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalnum(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
>
>
> template<typename _CharT>
> inline bool
> isgraph(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
>
>
> template<typename _CharT>
> inline _CharT
> toupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
>
>
> template<typename _CharT>
> inline _CharT
> tolower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 2 3
>
>namespace std
>{
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> class basic_ios : public ios_base
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
># 78 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> typedef ctype<_CharT> __ctype_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
>
>
>
> protected:
> basic_ostream<_CharT, _Traits>* _M_tie;
> mutable char_type _M_fill;
> mutable bool _M_fill_init;
> basic_streambuf<_CharT, _Traits>* _M_streambuf;
>
>
> const __ctype_type* _M_ctype;
>
> const __num_put_type* _M_num_put;
>
> const __num_get_type* _M_num_get;
>
> public:
>
>
>
>
>
>
>
> operator void*() const
> { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
>
> bool
> operator!() const
> { return this->fail(); }
># 122 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> iostate
> rdstate() const
> { return _M_streambuf_state; }
># 133 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> void
> clear(iostate __state = goodbit);
>
>
>
>
>
>
>
> void
> setstate(iostate __state)
> { this->clear(this->rdstate() | __state); }
>
>
>
>
> void
> _M_setstate(iostate __state)
> {
>
>
> _M_streambuf_state |= __state;
> if (this->exceptions() & __state)
> throw;
> }
>
>
>
>
>
>
>
> bool
> good() const
> { return this->rdstate() == 0; }
>
>
>
>
>
>
>
> bool
> eof() const
> { return (this->rdstate() & eofbit) != 0; }
># 186 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> bool
> fail() const
> { return (this->rdstate() & (badbit | failbit)) != 0; }
>
>
>
>
>
>
>
> bool
> bad() const
> { return (this->rdstate() & badbit) != 0; }
># 207 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> iostate
> exceptions() const
> { return _M_exception; }
># 242 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> void
> exceptions(iostate __except)
> {
> _M_exception = __except;
> this->clear(_M_streambuf_state);
> }
>
>
>
>
>
>
>
> explicit
> basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
> : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
> _M_ctype(0), _M_num_put(0), _M_num_get(0)
> { this->init(__sb); }
>
>
>
>
>
>
>
> virtual
> ~basic_ios() { }
># 280 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie() const
> { return _M_tie; }
># 292 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie(basic_ostream<_CharT, _Traits>* __tiestr)
> {
> basic_ostream<_CharT, _Traits>* __old = _M_tie;
> _M_tie = __tiestr;
> return __old;
> }
>
>
>
>
>
>
>
> basic_streambuf<_CharT, _Traits>*
> rdbuf() const
> { return _M_streambuf; }
># 332 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> basic_streambuf<_CharT, _Traits>*
> rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
># 346 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> basic_ios&
> copyfmt(const basic_ios& __rhs);
>
>
>
>
>
>
>
> char_type
> fill() const
> {
> if (!_M_fill_init)
> {
> _M_fill = this->widen(' ');
> _M_fill_init = true;
> }
> return _M_fill;
> }
># 375 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> char_type
> fill(char_type __ch)
> {
> char_type __old = this->fill();
> _M_fill = __ch;
> return __old;
> }
># 395 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> locale
> imbue(const locale& __loc);
># 415 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> char
> narrow(char_type __c, char __dfault) const;
># 433 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 3
> char_type
> widen(char __c) const;
>
> protected:
>
>
>
>
>
>
>
> basic_ios()
> : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
> _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
> { }
>
>
>
>
>
>
>
> void
> init(basic_streambuf<_CharT, _Traits>* __sb);
>
> void
> _M_cache_locale(const locale& __loc);
> };
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.tcc" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.tcc" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.tcc" 3
>
>namespace std
>{
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::clear(iostate __state)
> {
> if (this->rdbuf())
> _M_streambuf_state = __state;
> else
> _M_streambuf_state = __state | badbit;
> if (this->exceptions() & this->rdstate())
> __throw_ios_failure(("basic_ios::clear"));
> }
>
> template<typename _CharT, typename _Traits>
> basic_streambuf<_CharT, _Traits>*
> basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
> {
> basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
> _M_streambuf = __sb;
> this->clear();
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ios<_CharT, _Traits>&
> basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
> {
>
>
> if (this != &__rhs)
> {
>
>
>
>
> _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
> _M_local_word : new _Words[__rhs._M_word_size];
>
>
> _Callback_list* __cb = __rhs._M_callbacks;
> if (__cb)
> __cb->_M_add_reference();
> _M_call_callbacks(erase_event);
> if (_M_word != _M_local_word)
> {
> delete [] _M_word;
> _M_word = 0;
> }
> _M_dispose_callbacks();
>
>
> _M_callbacks = __cb;
> for (int __i = 0; __i < __rhs._M_word_size; ++__i)
> __words[__i] = __rhs._M_word[__i];
> _M_word = __words;
> _M_word_size = __rhs._M_word_size;
>
> this->flags(__rhs.flags());
> this->width(__rhs.width());
> this->precision(__rhs.precision());
> this->tie(__rhs.tie());
> this->fill(__rhs.fill());
> _M_ios_locale = __rhs.getloc();
> _M_cache_locale(_M_ios_locale);
>
> _M_call_callbacks(copyfmt_event);
>
>
> this->exceptions(__rhs.exceptions());
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> char
> basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
> { return __check_facet(_M_ctype).narrow(__c, __dfault); }
>
> template<typename _CharT, typename _Traits>
> _CharT
> basic_ios<_CharT, _Traits>::widen(char __c) const
> { return __check_facet(_M_ctype).widen(__c); }
>
>
> template<typename _CharT, typename _Traits>
> locale
> basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
> {
> locale __old(this->getloc());
> ios_base::imbue(__loc);
> _M_cache_locale(__loc);
> if (this->rdbuf() != 0)
> this->rdbuf()->pubimbue(__loc);
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
> {
>
> ios_base::_M_init();
>
>
> _M_cache_locale(_M_ios_locale);
># 159 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.tcc" 3
> _M_fill = _CharT();
> _M_fill_init = false;
>
> _M_tie = 0;
> _M_exception = goodbit;
> _M_streambuf = __sb;
> _M_streambuf_state = __sb ? goodbit : badbit;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
> {
> if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
> _M_ctype = &use_facet<__ctype_type>(__loc);
> else
> _M_ctype = 0;
>
> if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
> _M_num_put = &use_facet<__num_put_type>(__loc);
> else
> _M_num_put = 0;
>
> if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
> _M_num_get = &use_facet<__num_get_type>(__loc);
> else
> _M_num_get = 0;
> }
>
>
>
>
>
> extern template class basic_ios<char>;
>
>
> extern template class basic_ios<wchar_t>;
>
>
>}
># 465 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/basic_ios.h" 2 3
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ios" 2 3
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 2 3
>
>
>namespace std
>{
># 57 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
> typedef ctype<_CharT> __ctype_type;
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
> protected:
>
>
>
>
>
>
>
> streamsize _M_gcount;
>
> public:
># 103 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> explicit
> basic_istream(__streambuf_type* __sb): _M_gcount(streamsize(0))
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_istream()
> { _M_gcount = streamsize(0); }
>
>
> class sentry;
> friend class sentry;
># 130 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> inline __istream_type&
> operator>>(__istream_type& (*__pf)(__istream_type&));
>
> inline __istream_type&
> operator>>(__ios_type& (*__pf)(__ios_type&));
>
> inline __istream_type&
> operator>>(ios_base& (*__pf)(ios_base&));
># 168 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> operator>>(bool& __n);
>
> __istream_type&
> operator>>(short& __n);
>
> __istream_type&
> operator>>(unsigned short& __n);
>
> __istream_type&
> operator>>(int& __n);
>
> __istream_type&
> operator>>(unsigned int& __n);
>
> __istream_type&
> operator>>(long& __n);
>
> __istream_type&
> operator>>(unsigned long& __n);
>
>
> __istream_type&
> operator>>(long long& __n);
>
> __istream_type&
> operator>>(unsigned long long& __n);
>
>
> __istream_type&
> operator>>(float& __f);
>
> __istream_type&
> operator>>(double& __f);
>
> __istream_type&
> operator>>(long double& __f);
>
> __istream_type&
> operator>>(void*& __p);
># 229 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> operator>>(__streambuf_type* __sb);
># 239 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> inline streamsize
> gcount() const
> { return _M_gcount; }
># 271 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> int_type
> get();
># 285 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> get(char_type& __c);
># 312 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n, char_type __delim);
># 323 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> inline __istream_type&
> get(char_type* __s, streamsize __n)
> { return this->get(__s, __n, this->widen('\n')); }
># 346 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> get(__streambuf_type& __sb, char_type __delim);
># 356 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> inline __istream_type&
> get(__streambuf_type& __sb)
> { return this->get(__sb, this->widen('\n')); }
># 385 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n, char_type __delim);
># 396 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> inline __istream_type&
> getline(char_type* __s, streamsize __n)
> { return this->getline(__s, __n, this->widen('\n')); }
># 420 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> ignore();
>
> __istream_type&
> ignore(streamsize __n);
>
> __istream_type&
> ignore(streamsize __n, int_type __delim);
># 437 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> int_type
> peek();
># 455 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> read(char_type* __s, streamsize __n);
># 474 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> streamsize
> readsome(char_type* __s, streamsize __n);
># 490 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> putback(char_type __c);
># 505 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> unget();
># 523 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> int
> sync();
># 537 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> pos_type
> tellg();
># 552 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> seekg(pos_type);
># 568 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> __istream_type&
> seekg(off_type, ios_base::seekdir);
>
>
> protected:
> explicit
> basic_istream(): _M_gcount(streamsize(0)) { }
> };
>
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n, int_type __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n, int_type __delim);
># 621 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream<_CharT, _Traits>::sentry
> {
> public:
>
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef typename _Traits::int_type __int_type;
># 653 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> explicit
> sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
># 663 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> operator bool() const { return _M_ok; }
>
> private:
> bool _M_ok;
> };
># 682 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
>
> template<class _Traits>
> basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
>
> template<class _Traits>
> basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
># 723 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
>
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __in, char* __s);
>
> template<class _Traits>
> basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
>
> template<class _Traits>
> basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
># 750 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_iostream
> : public basic_istream<_CharT, _Traits>,
> public basic_ostream<_CharT, _Traits>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
>
>
>
>
> explicit
> basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
> : __istream_type(), __ostream_type()
> { this->init(__sb); }
>
>
>
>
> virtual
> ~basic_iostream() { }
>
> protected:
> explicit
> basic_iostream() : __istream_type(), __ostream_type()
> { }
> };
># 813 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __is);
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/istream.tcc" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/istream.tcc" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/istream.tcc" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/locale" 1 3
># 41 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/locale" 3
> 
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/locale" 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/typeinfo" 1 3
># 40 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/typeinfo" 3
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace __cxxabiv1
>{
> class __class_type_info;
>}
># 59 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/typeinfo" 3
>namespace std
>{
>
>
>
>
>
>
> class type_info
> {
> public:
>
>
>
>
> virtual ~type_info();
>
> private:
>
> type_info& operator=(const type_info&);
> type_info(const type_info&);
>
> protected:
> const char *__name;
>
> protected:
> explicit type_info(const char *__n): __name(__n) { }
>
> public:
>
>
>
> const char* name() const
> { return __name; }
># 105 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/typeinfo" 3
> bool before(const type_info& __arg) const
> { return __name < __arg.__name; }
> bool operator==(const type_info& __arg) const
> { return __name == __arg.__name; }
>
> bool operator!=(const type_info& __arg) const
> { return !operator==(__arg); }
>
>
> public:
>
> virtual bool __is_pointer_p() const;
>
> virtual bool __is_function_p() const;
>
>
>
>
>
>
>
> virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
> unsigned __outer) const;
>
>
> virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
> void **__obj_ptr) const;
> };
>
>
>
>
>
>
> class bad_cast : public exception
> {
> public:
> bad_cast() throw() { }
>
>
> virtual ~bad_cast() throw();
> };
>
>
> class bad_typeid : public exception
> {
> public:
> bad_typeid () throw() { }
>
>
> virtual ~bad_typeid() throw();
> };
>}
>
>#pragma GCC visibility pop
>
>}
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 2 3
>
>
>namespace std
>{
> template<typename _Facet>
> locale
> locale::combine(const locale& __other) const
> {
> _Impl* __tmp = new _Impl(*_M_impl, 1);
> try
> {
> __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
> }
> catch(...)
> {
> __tmp->_M_remove_reference();
> throw;
> }
> return locale(__tmp);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> bool
> locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
> const basic_string<_CharT, _Traits, _Alloc>& __s2) const
> {
> typedef std::collate<_CharT> __collate_type;
> const __collate_type& __collate = use_facet<__collate_type>(*this);
> return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
> __s2.data(), __s2.data() + __s2.length()) < 0);
> }
># 86 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _Facet>
> inline bool
> has_facet(const locale& __loc) throw()
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
> }
># 108 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _Facet>
> inline const _Facet&
> use_facet(const locale& __loc)
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
> __throw_bad_cast();
> return static_cast<const _Facet&>(*__facets[__i]);
> }
>
>
>
> template<typename _Facet>
> struct __use_cache
> {
> const _Facet*
> operator() (const locale& __loc) const;
> };
>
>
> template<typename _CharT>
> struct __use_cache<__numpunct_cache<_CharT> >
> {
> const __numpunct_cache<_CharT>*
> operator() (const locale& __loc) const
> {
> const size_t __i = numpunct<_CharT>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __numpunct_cache<_CharT>* __tmp = __null;
> try
> {
> __tmp = new __numpunct_cache<_CharT>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
> }
> };
>
> template<typename _CharT, bool _Intl>
> struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
> {
> const __moneypunct_cache<_CharT, _Intl>*
> operator() (const locale& __loc) const
> {
> const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __moneypunct_cache<_CharT, _Intl>* __tmp = __null;
> try
> {
> __tmp = new __moneypunct_cache<_CharT, _Intl>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<
> const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
> }
> };
>
> template<typename _CharT>
> void
> __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
> {
> _M_allocated = true;
>
> const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
>
> _M_grouping_size = __np.grouping().size();
> char* __grouping = new char[_M_grouping_size];
> __np.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = (_M_grouping_size
> && static_cast<signed char>(__np.grouping()[0]) > 0);
>
> _M_truename_size = __np.truename().size();
> _CharT* __truename = new _CharT[_M_truename_size];
> __np.truename().copy(__truename, _M_truename_size);
> _M_truename = __truename;
>
> _M_falsename_size = __np.falsename().size();
> _CharT* __falsename = new _CharT[_M_falsename_size];
> __np.falsename().copy(__falsename, _M_falsename_size);
> _M_falsename = __falsename;
>
> _M_decimal_point = __np.decimal_point();
> _M_thousands_sep = __np.thousands_sep();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(__num_base::_S_atoms_out,
> __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
> __ct.widen(__num_base::_S_atoms_in,
> __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
> }
>
> template<typename _CharT, bool _Intl>
> void
> __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
> {
> _M_allocated = true;
>
> const moneypunct<_CharT, _Intl>& __mp =
> use_facet<moneypunct<_CharT, _Intl> >(__loc);
>
> _M_grouping_size = __mp.grouping().size();
> char* __grouping = new char[_M_grouping_size];
> __mp.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = (_M_grouping_size
> && static_cast<signed char>(__mp.grouping()[0]) > 0);
>
> _M_decimal_point = __mp.decimal_point();
> _M_thousands_sep = __mp.thousands_sep();
> _M_frac_digits = __mp.frac_digits();
>
> _M_curr_symbol_size = __mp.curr_symbol().size();
> _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
> __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
> _M_curr_symbol = __curr_symbol;
>
> _M_positive_sign_size = __mp.positive_sign().size();
> _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
> __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
> _M_positive_sign = __positive_sign;
>
> _M_negative_sign_size = __mp.negative_sign().size();
> _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
> __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
> _M_negative_sign = __negative_sign;
>
> _M_pos_format = __mp.pos_format();
> _M_neg_format = __mp.neg_format();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(money_base::_S_atoms,
> money_base::_S_atoms + money_base::_S_end, _M_atoms);
> }
># 271 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> static bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp);
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, string& __xtrc) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> bool __testeof = __beg == __end;
>
>
> if (!__testeof)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> __xtrc += __plus ? '+' : '-';
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
> bool __found_mantissa = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero])
> {
> if (!__found_mantissa)
> {
> __xtrc += '0';
> __found_mantissa = true;
> }
> ++__sep_pos;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> break;
> }
>
>
> bool __found_dec = false;
> bool __found_sci = false;
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> const char_type* __q;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
>
>
> __xtrc.clear();
> break;
> }
> }
> else
> break;
> }
> else if (__c == __lc->_M_decimal_point)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
>
> if (__found_grouping.size())
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += '.';
> __found_dec = true;
> }
> else
> break;
> }
> else if ((__q = __traits_type::find(__lit_zero, 10, __c)))
> {
> __xtrc += __num_base::_S_atoms_in[__q - __lit];
> __found_mantissa = true;
> ++__sep_pos;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && !__found_sci && __found_mantissa)
> {
>
> if (__found_grouping.size() && !__found_dec)
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping
> && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> __xtrc += __plus ? '+' : '-';
> else
> continue;
> }
> else
> {
> __testeof = true;
> break;
> }
> }
> else
>
> break;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> if (!__found_dec && !__found_sci)
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err |= ios_base::failbit;
> }
>
>
> if (__testeof)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
>
>
> template<typename _ValueT>
> struct __to_unsigned_type
> { typedef _ValueT __type; };
>
> template<>
> struct __to_unsigned_type<long>
> { typedef unsigned long __type; };
>
>
> template<>
> struct __to_unsigned_type<long long>
> { typedef unsigned long long __type; };
>
>
>
>
> template<typename _CharT, typename _InIter>
> template<typename _ValueT>
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, _ValueT& __v) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef typename __to_unsigned_type<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> const ios_base::fmtflags __basefield = __io.flags()
> & ios_base::basefield;
> const bool __oct = __basefield == ios_base::oct;
> int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
>
>
> bool __testeof = __beg == __end;
>
>
> bool __negative = false;
> if (!__testeof)
> {
> __c = *__beg;
> if (numeric_limits<_ValueT>::is_signed)
> __negative = __c == __lit[__num_base::_S_iminus];
> if ((__negative || __c == __lit[__num_base::_S_iplus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
>
> bool __found_zero = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero]
> && (!__found_zero || __base == 10))
> {
> __found_zero = true;
> ++__sep_pos;
> if (__basefield == 0)
> __base = 8;
> if (__base == 8)
> __sep_pos = 0;
> }
> else if (__found_zero
> && (__c == __lit[__num_base::_S_ix]
> || __c == __lit[__num_base::_S_iX]))
> {
> if (__basefield == 0)
> __base = 16;
> if (__base == 16)
> {
> __found_zero = false;
> __sep_pos = 0;
> }
> else
> break;
> }
> else
> break;
>
> if (++__beg != __end)
> {
> __c = *__beg;
> if (!__found_zero)
> break;
> }
> else
> __testeof = true;
> }
>
>
>
> const size_t __len = (__base == 16 ? __num_base::_S_iend
> - __num_base::_S_izero : __base);
>
>
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> bool __testfail = false;
> const __unsigned_type __max = __negative ?
> -numeric_limits<_ValueT>::min() : numeric_limits<_ValueT>::max();
> const __unsigned_type __smax = __max / __base;
> __unsigned_type __result = 0;
> const char_type* __q;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
> __testfail = true;
> break;
> }
> }
> else if (__c == __lc->_M_decimal_point)
> break;
> else if ((__q = __traits_type::find(__lit_zero, __len, __c)))
> {
> int __digit = __q - __lit_zero;
> if (__digit > 15)
> __digit -= 6;
> if (__result > __smax)
> __testfail = true;
> else
> {
> __result *= __base;
> __testfail |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
> }
> else
>
> break;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err |= ios_base::failbit;
> }
>
> if (!__testfail && (__sep_pos || __found_zero
> || __found_grouping.size()))
> __v = __negative ? -__result : __result;
> else
> __err |= ios_base::failbit;
>
> if (__testeof)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, bool& __v) const
> {
> if (!(__io.flags() & ios_base::boolalpha))
> {
>
>
>
> long __l = -1;
> __beg = _M_extract_int(__beg, __end, __io, __err, __l);
> if (__l == 0 || __l == 1)
> __v = __l;
> else
> __err |= ios_base::failbit;
> }
> else
> {
>
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> bool __testf = true;
> bool __testt = true;
> size_t __n;
> bool __testeof = __beg == __end;
> for (__n = 0; !__testeof; ++__n)
> {
> const char_type __c = *__beg;
>
> if (__testf)
> if (__n < __lc->_M_falsename_size)
> __testf = __c == __lc->_M_falsename[__n];
> else
> break;
>
> if (__testt)
> if (__n < __lc->_M_truename_size)
> __testt = __c == __lc->_M_truename[__n];
> else
> break;
>
> if (!__testf && !__testt)
> break;
>
> if (++__beg == __end)
> __testeof = true;
> }
> if (__testf && __n == __lc->_M_falsename_size)
> __v = 0;
> else if (__testt && __n == __lc->_M_truename_size)
> __v = 1;
> else
> __err |= ios_base::failbit;
>
> if (__testeof)
> __err |= ios_base::eofbit;
> }
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned short& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned int& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, float& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> return __beg;
> }
># 796 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, void*& __v) const
> {
>
> typedef ios_base::fmtflags fmtflags;
> const fmtflags __fmt = __io.flags();
> __io.flags(__fmt & ~ios_base::basefield | ios_base::hex);
>
> unsigned long __ul;
> __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
>
>
> __io.flags(__fmt);
>
> if (!(__err & ios_base::failbit))
> __v = reinterpret_cast<void*>(__ul);
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
> _CharT* __new, const _CharT* __cs, int& __len) const
> {
>
>
> __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
> __w, __len, true);
> __len = static_cast<int>(__w);
> }
>
>
>
>
>
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, long __v, const _CharT* __lit,
> ios_base::fmtflags __flags)
> {
> unsigned long __ul = __v;
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> if (__builtin_expect(__basefield != ios_base::oct
> && __basefield != ios_base::hex, true))
> __ul = __v < 0 ? -__v : __ul;
> return __int_to_char(__bufend, __ul, __lit, __flags, false);
> }
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, unsigned long __v, const _CharT* __lit,
> ios_base::fmtflags __flags)
> { return __int_to_char(__bufend, __v, __lit, __flags, false); }
>
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, long long __v, const _CharT* __lit,
> ios_base::fmtflags __flags)
> {
> unsigned long long __ull = __v;
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> if (__builtin_expect(__basefield != ios_base::oct
> && __basefield != ios_base::hex, true))
> __ull = __v < 0 ? -__v : __ull;
> return __int_to_char(__bufend, __ull, __lit, __flags, false);
> }
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, unsigned long long __v,
> const _CharT* __lit, ios_base::fmtflags __flags)
> { return __int_to_char(__bufend, __v, __lit, __flags, false); }
>
>
>
> template<typename _CharT, typename _ValueT>
> int
> __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
> ios_base::fmtflags __flags, bool)
> {
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> _CharT* __buf = __bufend;
>
> if (__builtin_expect(__basefield != ios_base::oct
> && __basefield != ios_base::hex, true))
> {
>
> do
> {
> *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
> __v /= 10;
> }
> while (__v != 0);
> }
> else if (__basefield == ios_base::oct)
> {
>
> do
> {
> *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
> __v >>= 3;
> }
> while (__v != 0);
> }
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> const int __case_offset = __uppercase ? __num_base::_S_oudigits
> : __num_base::_S_odigits;
> do
> {
> *--__buf = __lit[(__v & 0xf) + __case_offset];
> __v >>= 4;
> }
> while (__v != 0);
> }
> return __bufend - __buf;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
> ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
> {
> _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size, __cs, __cs + __len);
> __len = __p - __new;
> }
>
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _OutIter
> num_put<_CharT, _OutIter>::
> _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
> _ValueT __v) const
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_out;
> const ios_base::fmtflags __flags = __io.flags();
>
>
> const int __ilen = 5 * sizeof(_ValueT);
> _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __ilen));
>
>
>
> int __len = __int_to_char(__cs + __ilen, __v, __lit, __flags);
> __cs += __ilen - __len;
>
>
> if (__lc->_M_use_grouping)
> {
>
>
> _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * (__len + 1)
> * 2));
> _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
> __cs = __cs2 + 2;
> }
>
>
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> if (__builtin_expect(__basefield != ios_base::oct
> && __basefield != ios_base::hex, true))
> {
>
> if (__v > 0)
> {
> if (__flags & ios_base::showpos
> && numeric_limits<_ValueT>::is_signed)
> *--__cs = __lit[__num_base::_S_oplus], ++__len;
> }
> else if (__v)
> *--__cs = __lit[__num_base::_S_ominus], ++__len;
> }
> else if (__flags & ios_base::showbase && __v)
> {
> if (__basefield == ios_base::oct)
> *--__cs = __lit[__num_base::_S_odigits], ++__len;
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> *--__cs = __lit[__num_base::_S_ox + __uppercase];
>
> *--__cs = __lit[__num_base::_S_odigits];
> __len += 2;
> }
> }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __cs3, __cs, __len);
> __cs = __cs3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __cs, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_float(const char* __grouping, size_t __grouping_size,
> _CharT __sep, const _CharT* __p, _CharT* __new,
> _CharT* __cs, int& __len) const
> {
>
>
>
> const int __declen = __p ? __p - __cs : __len;
> _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size,
> __cs, __cs + __declen);
>
>
> int __newlen = __p2 - __new;
> if (__p)
> {
> char_traits<_CharT>::copy(__p2, __p, __len - __declen);
> __newlen += __len - __declen;
> }
> __len = __newlen;
> }
># 1068 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _OutIter
> num_put<_CharT, _OutIter>::
> _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
> _ValueT __v) const
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
>
> streamsize __prec = __io.precision();
> if (__prec < static_cast<streamsize>(0))
> __prec = static_cast<streamsize>(6);
>
> const int __max_digits = numeric_limits<_ValueT>::digits10;
>
>
> int __len;
>
> char __fbuf[16];
>
>
>
>
> int __cs_size = __max_digits * 3;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
>
> __num_base::_S_format_float(__io, __fbuf, __mod);
> __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
> _S_get_c_locale(), __prec);
>
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
> _S_get_c_locale(), __prec);
> }
># 1132 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __ctype.widen(__cs, __cs + __len, __ws);
>
>
> const _CharT __cdec = __ctype.widen('.');
> const _CharT __dec = __lc->_M_decimal_point;
> const _CharT* __p = char_traits<_CharT>::find(__ws, __len, __cdec);
> if (__p)
> __ws[__p - __ws] = __dec;
>
>
>
>
> if (__lc->_M_use_grouping
> && (__p || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
> && __cs[1] >= '0' && __cs[2] >= '0')))
> {
>
>
> _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len * 2));
>
> streamsize __off = 0;
> if (__cs[0] == '-' || __cs[0] == '+')
> {
> __off = 1;
> __ws2[0] = __ws[0];
> __len -= 1;
> }
>
> _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __p, __ws2 + __off,
> __ws + __off, __len);
> __len += __off;
>
> __ws = __ws2;
> }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __ws3, __ws, __len);
> __ws = __ws3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __ws, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> if ((__flags & ios_base::boolalpha) == 0)
> {
> const long __l = __v;
> __s = _M_insert_int(__s, __io, __fill, __l);
> }
> else
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> const _CharT* __name = __v ? __lc->_M_truename
> : __lc->_M_falsename;
> int __len = __v ? __lc->_M_truename_size
> : __lc->_M_falsename_size;
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __cs
> = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __cs, __name, __len);
> __name = __cs;
> }
> __io.width(0);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
> { return _M_insert_float(__s, __io, __fill, char(), __v); }
># 1269 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long double __v) const
> { return _M_insert_float(__s, __io, __fill, 'L', __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> const void* __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> const ios_base::fmtflags __fmt = ~(ios_base::basefield
> | ios_base::uppercase
> | ios_base::internal);
> __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
>
> __s = _M_insert_int(__s, __io, __fill,
> reinterpret_cast<unsigned long>(__v));
> __io.flags(__flags);
> return __s;
> }
>
> template<typename _CharT, typename _InIter>
> template<bool _Intl>
> _InIter
> money_get<_CharT, _InIter>::
> _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, string& __units) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef typename string_type::size_type size_type;
> typedef money_base::part part;
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> __use_cache<__cache_type> __uc;
> const __cache_type* __lc = __uc(__loc);
> const char_type* __lit = __lc->_M_atoms;
>
>
> bool __negative = false;
>
> size_type __sign_size = 0;
>
> const bool __mandatory_sign = (__lc->_M_positive_sign_size
> && __lc->_M_negative_sign_size);
>
> string __grouping_tmp;
> if (__lc->_M_use_grouping)
> __grouping_tmp.reserve(32);
>
> int __last_pos = 0;
>
> int __n = 0;
>
> bool __testvalid = true;
>
> bool __testdecfound = false;
>
>
> string __res;
> __res.reserve(32);
>
> const char_type* __lit_zero = __lit + money_base::_S_zero;
> const money_base::pattern __p = __lc->_M_neg_format;
> for (int __i = 0; __i < 4 && __testvalid; ++__i)
> {
> const part __which = static_cast<part>(__p.field[__i]);
> switch (__which)
> {
> case money_base::symbol:
>
>
>
>
> if (__io.flags() & ios_base::showbase || __sign_size > 1
> || __i == 0
> || (__i == 1 && (__mandatory_sign
> || (static_cast<part>(__p.field[0])
> == money_base::sign)
> || (static_cast<part>(__p.field[2])
> == money_base::space)))
> || (__i == 2 && ((static_cast<part>(__p.field[3])
> == money_base::value)
> || __mandatory_sign
> && (static_cast<part>(__p.field[3])
> == money_base::sign))))
> {
> const size_type __len = __lc->_M_curr_symbol_size;
> size_type __j = 0;
> for (; __beg != __end && __j < __len
> && *__beg == __lc->_M_curr_symbol[__j];
> ++__beg, ++__j);
> if (__j != __len
> && (__j || __io.flags() & ios_base::showbase))
> __testvalid = false;
> }
> break;
> case money_base::sign:
>
> if (__lc->_M_positive_sign_size && __beg != __end
> && *__beg == __lc->_M_positive_sign[0])
> {
> __sign_size = __lc->_M_positive_sign_size;
> ++__beg;
> }
> else if (__lc->_M_negative_sign_size && __beg != __end
> && *__beg == __lc->_M_negative_sign[0])
> {
> __negative = true;
> __sign_size = __lc->_M_negative_sign_size;
> ++__beg;
> }
> else if (__lc->_M_positive_sign_size
> && !__lc->_M_negative_sign_size)
>
>
> __negative = true;
> else if (__mandatory_sign)
> __testvalid = false;
> break;
> case money_base::value:
>
>
> for (; __beg != __end; ++__beg)
> {
> const char_type __c = *__beg;
> const char_type* __q = __traits_type::find(__lit_zero,
> 10, __c);
> if (__q != 0)
> {
> __res += money_base::_S_atoms[__q - __lit];
> ++__n;
> }
> else if (__c == __lc->_M_decimal_point
> && !__testdecfound)
> {
> __last_pos = __n;
> __n = 0;
> __testdecfound = true;
> }
> else if (__lc->_M_use_grouping
> && __c == __lc->_M_thousands_sep
> && !__testdecfound)
> {
> if (__n)
> {
>
> __grouping_tmp += static_cast<char>(__n);
> __n = 0;
> }
> else
> {
> __testvalid = false;
> break;
> }
> }
> else
> break;
> }
> if (__res.empty())
> __testvalid = false;
> break;
> case money_base::space:
>
> if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
> ++__beg;
> else
> __testvalid = false;
> case money_base::none:
>
> if (__i != 3)
> for (; __beg != __end
> && __ctype.is(ctype_base::space, *__beg); ++__beg);
> break;
> }
> }
>
>
> if (__sign_size > 1 && __testvalid)
> {
> const char_type* __sign = __negative ? __lc->_M_negative_sign
> : __lc->_M_positive_sign;
> size_type __i = 1;
> for (; __beg != __end && __i < __sign_size
> && *__beg == __sign[__i]; ++__beg, ++__i);
>
> if (__i != __sign_size)
> __testvalid = false;
> }
>
> if (__testvalid)
> {
>
> if (__res.size() > 1)
> {
> const size_type __first = __res.find_first_not_of('0');
> const bool __only_zeros = __first == string::npos;
> if (__first)
> __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
> }
>
>
> if (__negative && __res[0] != '0')
> __res.insert(__res.begin(), '-');
>
>
> if (__grouping_tmp.size())
> {
>
> __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
> : __n);
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __grouping_tmp))
> __err |= ios_base::failbit;
> }
>
>
> if (__testdecfound && __lc->_M_frac_digits > 0
> && __n != __lc->_M_frac_digits)
> __testvalid = false;
> }
>
>
> if (!__testvalid)
> __err |= ios_base::failbit;
> else
> __units.swap(__res);
>
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
># 1527 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _InIter>
> _InIter
> money_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const
> {
> string __str;
> if (__intl)
> __beg = _M_extract<true>(__beg, __end, __io, __err, __str);
> else
> __beg = _M_extract<false>(__beg, __end, __io, __err, __str);
> std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> money_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __units) const
> {
> typedef typename string::size_type size_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> string __str;
> const iter_type __ret = __intl ? _M_extract<true>(__beg, __end, __io,
> __err, __str)
> : _M_extract<false>(__beg, __end, __io,
> __err, __str);
> const size_type __len = __str.size();
> if (__len)
> {
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __ctype.widen(__str.data(), __str.data() + __len, __ws);
> __units.assign(__ws, __len);
> }
>
> return __ret;
> }
>
> template<typename _CharT, typename _OutIter>
> template<bool _Intl>
> _OutIter
> money_put<_CharT, _OutIter>::
> _M_insert(iter_type __s, ios_base& __io, char_type __fill,
> const string_type& __digits) const
> {
> typedef typename string_type::size_type size_type;
> typedef money_base::part part;
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> __use_cache<__cache_type> __uc;
> const __cache_type* __lc = __uc(__loc);
> const char_type* __lit = __lc->_M_atoms;
>
>
>
> const char_type* __beg = __digits.data();
>
> money_base::pattern __p;
> const char_type* __sign;
> size_type __sign_size;
> if (!(*__beg == __lit[money_base::_S_minus]))
> {
> __p = __lc->_M_pos_format;
> __sign = __lc->_M_positive_sign;
> __sign_size = __lc->_M_positive_sign_size;
> }
> else
> {
> __p = __lc->_M_neg_format;
> __sign = __lc->_M_negative_sign;
> __sign_size = __lc->_M_negative_sign_size;
> if (__digits.size())
> ++__beg;
> }
>
>
> size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
> __beg + __digits.size()) - __beg;
> if (__len)
> {
>
>
>
> string_type __value;
> __value.reserve(2 * __len);
>
>
>
> int __paddec = __len - __lc->_M_frac_digits;
> if (__paddec > 0)
> {
> if (__lc->_M_frac_digits < 0)
> __paddec = __len;
> if (__lc->_M_grouping_size)
> {
> _CharT* __ws =
> static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * 2 * __len));
> _CharT* __ws_end =
> std::__add_grouping(__ws, __lc->_M_thousands_sep,
> __lc->_M_grouping,
> __lc->_M_grouping_size,
> __beg, __beg + __paddec);
> __value.assign(__ws, __ws_end - __ws);
> }
> else
> __value.assign(__beg, __paddec);
> }
>
>
> if (__lc->_M_frac_digits > 0)
> {
> __value += __lc->_M_decimal_point;
> if (__paddec >= 0)
> __value.append(__beg + __paddec, __lc->_M_frac_digits);
> else
> {
>
> __value.append(-__paddec, __lit[money_base::_S_zero]);
> __value.append(__beg, __len);
> }
> }
>
>
> const ios_base::fmtflags __f = __io.flags()
> & ios_base::adjustfield;
> __len = __value.size() + __sign_size;
> __len += ((__io.flags() & ios_base::showbase)
> ? __lc->_M_curr_symbol_size : 0);
>
> string_type __res;
> __res.reserve(2 * __len);
>
> const size_type __width = static_cast<size_type>(__io.width());
> const bool __testipad = (__f == ios_base::internal
> && __len < __width);
>
> for (int __i = 0; __i < 4; ++__i)
> {
> const part __which = static_cast<part>(__p.field[__i]);
> switch (__which)
> {
> case money_base::symbol:
> if (__io.flags() & ios_base::showbase)
> __res.append(__lc->_M_curr_symbol,
> __lc->_M_curr_symbol_size);
> break;
> case money_base::sign:
>
>
>
> if (__sign_size)
> __res += __sign[0];
> break;
> case money_base::value:
> __res += __value;
> break;
> case money_base::space:
>
>
>
> if (__testipad)
> __res.append(__width - __len, __fill);
> else
> __res += __fill;
> break;
> case money_base::none:
> if (__testipad)
> __res.append(__width - __len, __fill);
> break;
> }
> }
>
>
> if (__sign_size > 1)
> __res.append(__sign + 1, __sign_size - 1);
>
>
> __len = __res.size();
> if (__width > __len)
> {
> if (__f == ios_base::left)
>
> __res.append(__width - __len, __fill);
> else
>
> __res.insert(0, __width - __len, __fill);
> __len = __width;
> }
>
>
> __s = std::__write(__s, __res.data(), __len);
> }
> __io.width(0);
> return __s;
> }
># 1743 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> _OutIter
> money_put<_CharT, _OutIter>::
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> long double __units) const
> {
> const locale __loc = __io.getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>
> int __cs_size = 64;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
>
>
> int __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
> _S_get_c_locale(), 0);
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
> _S_get_c_locale(), 0);
> }
>
>
>
>
>
>
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __cs_size));
> __ctype.widen(__cs, __cs + __len, __ws);
> const string_type __digits(__ws, __len);
> return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
> : _M_insert<false>(__s, __io, __fill, __digits);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> money_put<_CharT, _OutIter>::
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> const string_type& __digits) const
> { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
> : _M_insert<false>(__s, __io, __fill, __digits); }
>
>
>
>
>
>
> template<typename _CharT, typename _InIter>
> time_base::dateorder
> time_get<_CharT, _InIter>::do_date_order() const
> { return time_base::no_order; }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm,
> const _CharT* __format) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const size_t __len = char_traits<_CharT>::length(__format);
>
> for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
> {
> if (__ctype.narrow(__format[__i], 0) == '%')
> {
>
> char __c = __ctype.narrow(__format[++__i], 0);
> int __mem = 0;
> if (__c == 'E' || __c == 'O')
> __c = __ctype.narrow(__format[++__i], 0);
> switch (__c)
> {
> const char* __cs;
> _CharT __wcs[10];
> case 'a':
>
> const char_type* __days1[7];
> __tp._M_days_abbreviated(__days1);
> __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
> 7, __io, __err);
> break;
> case 'A':
>
> const char_type* __days2[7];
> __tp._M_days(__days2);
> __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
> 7, __io, __err);
> break;
> case 'h':
> case 'b':
>
> const char_type* __months1[12];
> __tp._M_months_abbreviated(__months1);
> __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
> __months1, 12, __io, __err);
> break;
> case 'B':
>
> const char_type* __months2[12];
> __tp._M_months(__months2);
> __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
> __months2, 12, __io, __err);
> break;
> case 'c':
>
> const char_type* __dt[2];
> __tp._M_date_time_formats(__dt);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dt[0]);
> break;
> case 'd':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
> __io, __err);
> break;
> case 'e':
>
>
> if (__ctype.is(ctype_base::space, *__beg))
> __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
> 1, __io, __err);
> else
> __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
> 2, __io, __err);
> break;
> case 'D':
>
> __cs = "%m/%d/%y";
> __ctype.widen(__cs, __cs + 9, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __wcs);
> break;
> case 'H':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
> __io, __err);
> break;
> case 'I':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
> __io, __err);
> break;
> case 'm':
>
> __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
> __io, __err);
> if (!__err)
> __tm->tm_mon = __mem - 1;
> break;
> case 'M':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
> __io, __err);
> break;
> case 'n':
> if (__ctype.narrow(*__beg, 0) == '\n')
> ++__beg;
> else
> __err |= ios_base::failbit;
> break;
> case 'R':
>
> __cs = "%H:%M";
> __ctype.widen(__cs, __cs + 6, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __wcs);
> break;
> case 'S':
>
>
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
>
>
>
> __io, __err);
> break;
> case 't':
> if (__ctype.narrow(*__beg, 0) == '\t')
> ++__beg;
> else
> __err |= ios_base::failbit;
> break;
> case 'T':
>
> __cs = "%H:%M:%S";
> __ctype.widen(__cs, __cs + 9, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __wcs);
> break;
> case 'x':
>
> const char_type* __dates[2];
> __tp._M_date_formats(__dates);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dates[0]);
> break;
> case 'X':
>
> const char_type* __times[2];
> __tp._M_time_formats(__times);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __times[0]);
> break;
> case 'y':
> case 'C':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
> __io, __err);
> break;
> case 'Y':
>
> __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
> __io, __err);
> if (!__err)
> __tm->tm_year = __mem - 1900;
> break;
> case 'Z':
>
> if (__ctype.is(ctype_base::upper, *__beg))
> {
> int __tmp;
> __beg = _M_extract_name(__beg, __end, __tmp,
> __timepunct_cache<_CharT>::_S_timezones,
> 14, __io, __err);
>
>
> if (__beg != __end && !__err && __tmp == 0
> && (*__beg == __ctype.widen('-')
> || *__beg == __ctype.widen('+')))
> {
> __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
> __io, __err);
> __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
> __io, __err);
> }
> }
> else
> __err |= ios_base::failbit;
> break;
> default:
>
> __err |= ios_base::failbit;
> }
> }
> else
> {
>
> if (__format[__i] == *__beg)
> ++__beg;
> else
> __err |= ios_base::failbit;
> }
> }
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_num(iter_type __beg, iter_type __end, int& __member,
> int __min, int __max, size_t __len,
> ios_base& __io, ios_base::iostate& __err) const
> {
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>
> int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
>
> ++__min;
> size_t __i = 0;
> int __value = 0;
> for (; __beg != __end && __i < __len; ++__beg, ++__i)
> {
> const char __c = __ctype.narrow(*__beg, '*');
> if (__c >= '0' && __c <= '9')
> {
> __value = __value * 10 + (__c - '0');
> const int __valuec = __value * __mult;
> if (__valuec > __max || __valuec + __mult < __min)
> break;
> __mult /= 10;
> }
> else
> break;
> }
> if (__i == __len)
> __member = __value;
> else
> __err |= ios_base::failbit;
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_name(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
> * __indexlen));
> size_t __nmatches = 0;
> size_t __pos = 0;
> bool __testvalid = true;
> const char_type* __name;
>
>
>
>
>
> if (__beg != __end)
> {
> const char_type __c = *__beg;
> for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
> if (__c == __names[__i1][0]
> || __c == __ctype.toupper(__names[__i1][0]))
> __matches[__nmatches++] = __i1;
> }
>
> while (__nmatches > 1)
> {
>
> size_t __minlen = __traits_type::length(__names[__matches[0]]);
> for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
> __minlen = std::min(__minlen,
> __traits_type::length(__names[__matches[__i2]]));
> ++__beg, ++__pos;
> if (__pos < __minlen && __beg != __end)
> for (size_t __i3 = 0; __i3 < __nmatches;)
> {
> __name = __names[__matches[__i3]];
> if (!(__name[__pos] == *__beg))
> __matches[__i3] = __matches[--__nmatches];
> else
> ++__i3;
> }
> else
> break;
> }
>
> if (__nmatches == 1)
> {
>
> ++__beg, ++__pos;
> __name = __names[__matches[0]];
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
> ++__beg, ++__pos;
>
> if (__len == __pos)
> __member = __matches[0];
> else
> __testvalid = false;
> }
> else
> __testvalid = false;
> if (!__testvalid)
> __err |= ios_base::failbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const char_type* __times[2];
> __tp._M_time_formats(__times);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __times[0]);
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const char_type* __dates[2];
> __tp._M_date_formats(__dates);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dates[0]);
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const char_type* __days[7];
> __tp._M_days_abbreviated(__days);
> int __tmpwday;
> __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7, __io, __err);
>
>
>
>
>
>
>
> if (!__err && __beg != __end)
> {
> size_t __pos = __traits_type::length(__days[__tmpwday]);
> __tp._M_days(__days);
> const char_type* __name = __days[__tmpwday];
> if (__name[__pos] == *__beg)
> {
>
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end
> && __name[__pos] == *__beg)
> ++__beg, ++__pos;
> if (__len != __pos)
> __err |= ios_base::failbit;
> }
> }
> if (!__err)
> __tm->tm_wday = __tmpwday;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_monthname(iter_type __beg, iter_type __end,
> ios_base& __io, ios_base::iostate& __err, tm* __tm) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const char_type* __months[12];
> __tp._M_months_abbreviated(__months);
> int __tmpmon;
> __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
> __io, __err);
>
>
>
>
>
>
>
> if (!__err && __beg != __end)
> {
> size_t __pos = __traits_type::length(__months[__tmpmon]);
> __tp._M_months(__months);
> const char_type* __name = __months[__tmpmon];
> if (__name[__pos] == *__beg)
> {
>
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end
> && __name[__pos] == *__beg)
> ++__beg, ++__pos;
> if (__len != __pos)
> __err |= ios_base::failbit;
> }
> }
> if (!__err)
> __tm->tm_mon = __tmpmon;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> size_t __i = 0;
> int __value = 0;
> for (; __beg != __end && __i < 4; ++__beg, ++__i)
> {
> const char __c = __ctype.narrow(*__beg, '*');
> if (__c >= '0' && __c <= '9')
> __value = __value * 10 + (__c - '0');
> else
> break;
> }
> if (__i == 2 || __i == 4)
> __tm->tm_year = __i == 2 ? __value : __value - 1900;
> else
> __err |= ios_base::failbit;
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> time_put<_CharT, _OutIter>::
> put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> const _CharT* __beg, const _CharT* __end) const
> {
> const locale& __loc = __io._M_getloc();
> ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
> for (; __beg != __end; ++__beg)
> if (__ctype.narrow(*__beg, 0) != '%')
> {
> *__s = *__beg;
> ++__s;
> }
> else if (++__beg != __end)
> {
> char __format;
> char __mod = 0;
> const char __c = __ctype.narrow(*__beg, 0);
> if (__c != 'E' && __c != 'O')
> __format = __c;
> else if (++__beg != __end)
> {
> __mod = __c;
> __format = __ctype.narrow(*__beg, 0);
> }
> else
> break;
> __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
> }
> else
> break;
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> time_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
> char __format, char __mod) const
> {
> const locale& __loc = __io._M_getloc();
> ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
> __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
>
>
>
> const size_t __maxlen = 128;
> char_type* __res =
> static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
>
>
>
>
>
>
> char_type __fmt[4];
> __fmt[0] = __ctype.widen('%');
> if (!__mod)
> {
> __fmt[1] = __format;
> __fmt[2] = char_type();
> }
> else
> {
> __fmt[1] = __mod;
> __fmt[2] = __format;
> __fmt[3] = char_type();
> }
>
> __tp._M_put(__res, __maxlen, __fmt, __tm);
>
>
> return std::__write(__s, __res, char_traits<char_type>::length(__res));
> }
>
>
> template<typename _CharT>
> int
> collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
> { return 0; }
>
>
> template<typename _CharT>
> size_t
> collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
> { return 0; }
>
> template<typename _CharT>
> int
> collate<_CharT>::
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const
> {
>
>
> const string_type __one(__lo1, __hi1);
> const string_type __two(__lo2, __hi2);
>
> const _CharT* __p = __one.c_str();
> const _CharT* __pend = __one.data() + __one.length();
> const _CharT* __q = __two.c_str();
> const _CharT* __qend = __two.data() + __two.length();
>
>
>
>
> for (;;)
> {
> const int __res = _M_compare(__p, __q);
> if (__res)
> return __res;
>
> __p += char_traits<_CharT>::length(__p);
> __q += char_traits<_CharT>::length(__q);
> if (__p == __pend && __q == __qend)
> return 0;
> else if (__p == __pend)
> return -1;
> else if (__q == __qend)
> return 1;
>
> __p++;
> __q++;
> }
> }
>
> template<typename _CharT>
> typename collate<_CharT>::string_type
> collate<_CharT>::
> do_transform(const _CharT* __lo, const _CharT* __hi) const
> {
>
> string_type __str(__lo, __hi);
>
> const _CharT* __p = __str.c_str();
> const _CharT* __pend = __str.data() + __str.length();
>
> size_t __len = (__hi - __lo) * 2;
>
> string_type __ret;
>
>
>
>
> for (;;)
> {
>
> _CharT* __c =
> static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
> size_t __res = _M_transform(__c, __p, __len);
>
>
> if (__res >= __len)
> {
> __len = __res + 1;
> __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __res = _M_transform(__c, __p, __len);
> }
>
> __ret.append(__c, __res);
> __p += char_traits<_CharT>::length(__p);
> if (__p == __pend)
> return __ret;
>
> __p++;
> __ret.push_back(_CharT());
> }
> }
>
> template<typename _CharT>
> long
> collate<_CharT>::
> do_hash(const _CharT* __lo, const _CharT* __hi) const
> {
> unsigned long __val = 0;
> for (; __lo < __hi; ++__lo)
> __val = *__lo + ((__val << 7) |
> (__val >> (numeric_limits<unsigned long>::digits - 7)));
> return static_cast<long>(__val);
> }
># 2469 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _Traits>
> void
> __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
> _CharT* __news, const _CharT* __olds,
> const streamsize __newlen,
> const streamsize __oldlen, const bool __num)
> {
> const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
> const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
>
>
> if (__adjust == ios_base::left)
> {
> _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
> _Traits::assign(__news + __oldlen, __plen, __fill);
> return;
> }
>
> size_t __mod = 0;
> if (__adjust == ios_base::internal && __num)
> {
>
>
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> const bool __testsign = (__ctype.widen('-') == __olds[0]
> || __ctype.widen('+') == __olds[0]);
> const bool __testhex = (__ctype.widen('0') == __olds[0]
> && __oldlen > 1
> && (__ctype.widen('x') == __olds[1]
> || __ctype.widen('X') == __olds[1]));
> if (__testhex)
> {
> __news[0] = __olds[0];
> __news[1] = __olds[1];
> __mod = 2;
> __news += 2;
> }
> else if (__testsign)
> {
> __news[0] = __olds[0];
> __mod = 1;
> ++__news;
> }
>
> }
> _Traits::assign(__news, __plen, __fill);
> _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
> __oldlen - __mod);
> }
>
> bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp)
> {
> const size_t __n = __grouping_tmp.size() - 1;
> const size_t __min = std::min(__n, size_t(__grouping_size - 1));
> size_t __i = __n;
> bool __test = true;
>
>
>
>
> for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
> __test = __grouping_tmp[__i] == __grouping[__j];
> for (; __i && __test; --__i)
> __test = __grouping_tmp[__i] == __grouping[__min];
>
>
>
> if (static_cast<signed char>(__grouping[__min]) > 0)
> __test &= __grouping_tmp[0] <= __grouping[__min];
> return __test;
> }
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last)
> {
> if (__last - __first > *__gbeg
> && static_cast<signed char>(*__gbeg) > 0)
> {
> const bool __bump = __gsize != 1;
> __s = std::__add_grouping(__s, __sep, __gbeg + __bump,
> __gsize - __bump, __first,
> __last - *__gbeg);
> __first = __last - *__gbeg;
> *__s++ = __sep;
> }
> do
> *__s++ = *__first++;
> while (__first != __last);
> return __s;
> }
>
>
>
>
>
> extern template class moneypunct<char, false>;
> extern template class moneypunct<char, true>;
> extern template class moneypunct_byname<char, false>;
> extern template class moneypunct_byname<char, true>;
> extern template class money_get<char>;
> extern template class money_put<char>;
> extern template class numpunct<char>;
> extern template class numpunct_byname<char>;
> extern template class num_get<char>;
> extern template class num_put<char>;
> extern template class __timepunct<char>;
> extern template class time_put<char>;
> extern template class time_put_byname<char>;
> extern template class time_get<char>;
> extern template class time_get_byname<char>;
> extern template class messages<char>;
> extern template class messages_byname<char>;
> extern template class ctype_byname<char>;
> extern template class codecvt_byname<char, char, mbstate_t>;
> extern template class collate<char>;
> extern template class collate_byname<char>;
>
> extern template
> const codecvt<char, char, mbstate_t>&
> use_facet<codecvt<char, char, mbstate_t> >(const locale&);
>
> extern template
> const collate<char>&
> use_facet<collate<char> >(const locale&);
>
> extern template
> const numpunct<char>&
> use_facet<numpunct<char> >(const locale&);
>
> extern template
> const num_put<char>&
> use_facet<num_put<char> >(const locale&);
>
> extern template
> const num_get<char>&
> use_facet<num_get<char> >(const locale&);
>
> extern template
> const moneypunct<char, true>&
> use_facet<moneypunct<char, true> >(const locale&);
>
> extern template
> const moneypunct<char, false>&
> use_facet<moneypunct<char, false> >(const locale&);
>
> extern template
> const money_put<char>&
> use_facet<money_put<char> >(const locale&);
>
> extern template
> const money_get<char>&
> use_facet<money_get<char> >(const locale&);
>
> extern template
> const __timepunct<char>&
> use_facet<__timepunct<char> >(const locale&);
>
> extern template
> const time_put<char>&
> use_facet<time_put<char> >(const locale&);
>
> extern template
> const time_get<char>&
> use_facet<time_get<char> >(const locale&);
>
> extern template
> const messages<char>&
> use_facet<messages<char> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<char> >(const locale&);
>
> extern template
> bool
> has_facet<codecvt<char, char, mbstate_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<char> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<moneypunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<money_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<money_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<__timepunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<time_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<time_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<messages<char> >(const locale&);
>
>
> extern template class moneypunct<wchar_t, false>;
> extern template class moneypunct<wchar_t, true>;
> extern template class moneypunct_byname<wchar_t, false>;
> extern template class moneypunct_byname<wchar_t, true>;
> extern template class money_get<wchar_t>;
> extern template class money_put<wchar_t>;
> extern template class numpunct<wchar_t>;
> extern template class numpunct_byname<wchar_t>;
> extern template class num_get<wchar_t>;
> extern template class num_put<wchar_t>;
> extern template class __timepunct<wchar_t>;
> extern template class time_put<wchar_t>;
> extern template class time_put_byname<wchar_t>;
> extern template class time_get<wchar_t>;
> extern template class time_get_byname<wchar_t>;
> extern template class messages<wchar_t>;
> extern template class messages_byname<wchar_t>;
> extern template class ctype_byname<wchar_t>;
> extern template class codecvt_byname<wchar_t, char, mbstate_t>;
> extern template class collate<wchar_t>;
> extern template class collate_byname<wchar_t>;
>
> extern template
> const codecvt<wchar_t, char, mbstate_t>&
> use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
>
> extern template
> const collate<wchar_t>&
> use_facet<collate<wchar_t> >(const locale&);
>
> extern template
> const numpunct<wchar_t>&
> use_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> const num_put<wchar_t>&
> use_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> const num_get<wchar_t>&
> use_facet<num_get<wchar_t> >(const locale&);
>
> extern template
> const moneypunct<wchar_t, true>&
> use_facet<moneypunct<wchar_t, true> >(const locale&);
>
> extern template
> const moneypunct<wchar_t, false>&
> use_facet<moneypunct<wchar_t, false> >(const locale&);
>
> extern template
> const money_put<wchar_t>&
> use_facet<money_put<wchar_t> >(const locale&);
>
> extern template
> const money_get<wchar_t>&
> use_facet<money_get<wchar_t> >(const locale&);
>
> extern template
> const __timepunct<wchar_t>&
> use_facet<__timepunct<wchar_t> >(const locale&);
>
> extern template
> const time_put<wchar_t>&
> use_facet<time_put<wchar_t> >(const locale&);
>
> extern template
> const time_get<wchar_t>&
> use_facet<time_get<wchar_t> >(const locale&);
>
> extern template
> const messages<wchar_t>&
> use_facet<messages<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<moneypunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<money_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<money_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<__timepunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<time_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<time_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<messages<wchar_t> >(const locale&);
>
>
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/locale" 2 3
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/istream.tcc" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
>
>
>
>namespace std
>{
># 56 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> template<typename _CharT, typename _Traits>
> class basic_ostream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef ctype<_CharT> __ctype_type;
>
> template<typename _CharT2, typename _Traits2>
> friend basic_ostream<_CharT2, _Traits2>&
> operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);
>
> template<typename _Traits2>
> friend basic_ostream<char, _Traits2>&
> operator<<(basic_ostream<char, _Traits2>&, char);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_ostream<_CharT2, _Traits2>&
> operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);
>
> template<typename _Traits2>
> friend basic_ostream<char, _Traits2>&
> operator<<(basic_ostream<char, _Traits2>&, const char*);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_ostream<_CharT2, _Traits2>&
> operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);
># 103 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> explicit
> basic_ostream(__streambuf_type* __sb)
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_ostream() { }
>
>
> class sentry;
> friend class sentry;
># 129 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> inline __ostream_type&
> operator<<(__ostream_type& (*__pf)(__ostream_type&));
>
> inline __ostream_type&
> operator<<(__ios_type& (*__pf)(__ios_type&));
>
> inline __ostream_type&
> operator<<(ios_base& (*__pf) (ios_base&));
># 166 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> operator<<(long __n);
>
> __ostream_type&
> operator<<(unsigned long __n);
>
> __ostream_type&
> operator<<(bool __n);
>
> __ostream_type&
> operator<<(short __n);
>
> __ostream_type&
> operator<<(unsigned short __n);
>
> __ostream_type&
> operator<<(int __n);
>
> __ostream_type&
> operator<<(unsigned int __n);
>
>
> __ostream_type&
> operator<<(long long __n);
>
> __ostream_type&
> operator<<(unsigned long long __n);
>
>
> __ostream_type&
> operator<<(double __f);
>
> __ostream_type&
> operator<<(float __f);
>
> __ostream_type&
> operator<<(long double __f);
>
> __ostream_type&
> operator<<(const void* __p);
># 228 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> operator<<(__streambuf_type* __sb);
># 261 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> put(char_type __c);
>
>
> void
> _M_write(const char_type* __s, streamsize __n)
> {
> streamsize __put = this->rdbuf()->sputn(__s, __n);
> if (__put != __n)
> this->setstate(ios_base::badbit);
> }
># 289 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> write(const char_type* __s, streamsize __n);
># 302 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> flush();
># 313 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> pos_type
> tellp();
># 324 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> seekp(pos_type);
># 336 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> __ostream_type&
> seekp(off_type, ios_base::seekdir);
>
> protected:
> explicit
> basic_ostream() { }
> };
># 354 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> template <typename _CharT, typename _Traits>
> class basic_ostream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
> basic_ostream<_CharT,_Traits>& _M_os;
>
> public:
># 373 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> explicit
> sentry(basic_ostream<_CharT,_Traits>& __os);
># 383 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> ~sentry()
> {
>
> if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
> {
>
> if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
> _M_os.setstate(ios_base::badbit);
> }
> }
># 401 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> operator bool() const
> { return _M_ok; }
> };
># 422 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
> { return (__out << __out.widen(__c)); }
>
>
> template <class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c);
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
> { return (__out << static_cast<char>(__c)); }
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
> { return (__out << static_cast<char>(__c)); }
># 462 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits> &
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const char* __s);
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
>
> template<class _Traits>
> basic_ostream<char, _Traits> &
> operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
># 496 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 3
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> endl(basic_ostream<_CharT, _Traits>& __os)
> { return flush(__os.put(__os.widen('\n'))); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> ends(basic_ostream<_CharT, _Traits>& __os)
> { return __os.put(_CharT()); }
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> flush(basic_ostream<_CharT, _Traits>& __os)
> { return __os.flush(); }
>
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ostream.tcc" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ostream.tcc" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/ostream.tcc" 3
>
>
>
>namespace std
>{
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>::sentry::
> sentry(basic_ostream<_CharT, _Traits>& __os)
> : _M_ok(false), _M_os(__os)
> {
>
> if (__os.tie() && __os.good())
> __os.tie()->flush();
>
> if (__os.good())
> _M_ok = true;
> else
> __os.setstate(ios_base::failbit);
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__ostream_type& (*__pf)(__ostream_type&))
> {
>
>
>
> return __pf(*this);
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__ios_type& (*__pf)(__ios_type&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(ios_base& (*__pf)(ios_base&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(bool __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(short __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
>
>
> long __l;
> const ios_base::fmtflags __fmt = (this->flags()
> & ios_base::basefield);
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> __l = static_cast<long>(static_cast<unsigned short>(__n));
> else
> __l = static_cast<long>(__n);
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __l).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(unsigned short __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
>
>
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(),
> static_cast<unsigned long>(__n)).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(int __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
>
>
> long __l;
> const ios_base::fmtflags __fmt = (this->flags()
> & ios_base::basefield);
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> __l = static_cast<long>(static_cast<unsigned int>(__n));
> else
> __l = static_cast<long>(__n);
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __l).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(unsigned int __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
>
>
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(),
> static_cast<unsigned long>(__n)).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(unsigned long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(long long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(unsigned long long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(float __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
>
>
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(),
> static_cast<double>(__n)).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(double __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(long double __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(const void* __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__streambuf_type* __sbin)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this);
> if (__cerb && __sbin)
> {
> try
> {
> if (!__copy_streambufs(__sbin, this->rdbuf()))
> __err |= ios_base::failbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbin)
> __err |= ios_base::badbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> put(char_type __c)
> {
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __put = this->rdbuf()->sputc(__c);
> if (traits_type::eq_int_type(__put, traits_type::eof()))
> __err |= ios_base::badbit;
> }
> catch (...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> write(const _CharT* __s, streamsize __n)
> {
>
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> try
> { _M_write(__s, __n); }
> catch (...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> flush()
> {
>
>
>
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_ostream<_CharT, _Traits>::pos_type
> basic_ostream<_CharT, _Traits>::
> tellp()
> {
> pos_type __ret = pos_type(-1);
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(pos_type __pos)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(off_type __off, ios_base::seekdir __dir)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = 1;
> _CharT* __cs = &__c;
> if (__w > __len)
> {
> __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
> &__c, __w, __len, false);
> __len = __w;
> }
> __out._M_write(__cs, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> return __out;
> }
>
>
> template <class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c)
> {
> typedef basic_ostream<char, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = 1;
> char* __cs = &__c;
> if (__w > __len)
> {
> __cs = static_cast<char*>(__builtin_alloca(__w));
> __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
> &__c, __w, __len, false);
> __len = __w;
> }
> __out._M_write(__cs, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb && __s)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(_Traits::length(__s));
> if (__w > __len)
> {
> _CharT* __cs = (static_cast<
> _CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w)));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
> __s, __w, __len, false);
> __s = __cs;
> __len = __w;
> }
> __out._M_write(__s, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> else if (!__s)
> __out.setstate(ios_base::badbit);
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
> typedef char_traits<char> __traits_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb && __s)
> {
> size_t __clen = __traits_type::length(__s);
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __clen));
> for (size_t __i = 0; __i < __clen; ++__i)
> __ws[__i] = __out.widen(__s[__i]);
> _CharT* __str = __ws;
>
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(__clen);
> if (__w > __len)
> {
> _CharT* __cs = (static_cast<
> _CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w)));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
> __ws, __w, __len, false);
> __str = __cs;
> __len = __w;
> }
> __out._M_write(__str, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> else if (!__s)
> __out.setstate(ios_base::badbit);
> return __out;
> }
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
> {
> typedef basic_ostream<char, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb && __s)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(_Traits::length(__s));
> if (__w > __len)
> {
> char* __cs = static_cast<char*>(__builtin_alloca(__w));
> __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
> __s, __w, __len, false);
> __s = __cs;
> __len = __w;
> }
> __out._M_write(__s, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> else if (!__s)
> __out.setstate(ios_base::badbit);
> return __out;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out,
> const basic_string<_CharT, _Traits, _Alloc>& __str)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(__str.size());
> const _CharT* __s = __str.data();
>
>
>
> if (__w > __len)
> {
> _CharT* __cs = (static_cast<
> _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
> __w, __len, false);
> __s = __cs;
> __len = __w;
> }
> __out._M_write(__s, __len);
> __out.width(0);
> }
> return __out;
> }
>
>
>
>
>
> extern template class basic_ostream<char>;
> extern template ostream& endl(ostream&);
> extern template ostream& ends(ostream&);
> extern template ostream& flush(ostream&);
> extern template ostream& operator<<(ostream&, char);
> extern template ostream& operator<<(ostream&, unsigned char);
> extern template ostream& operator<<(ostream&, signed char);
> extern template ostream& operator<<(ostream&, const char*);
> extern template ostream& operator<<(ostream&, const unsigned char*);
> extern template ostream& operator<<(ostream&, const signed char*);
>
>
> extern template class basic_ostream<wchar_t>;
> extern template wostream& endl(wostream&);
> extern template wostream& ends(wostream&);
> extern template wostream& flush(wostream&);
> extern template wostream& operator<<(wostream&, wchar_t);
> extern template wostream& operator<<(wostream&, char);
> extern template wostream& operator<<(wostream&, const wchar_t*);
> extern template wostream& operator<<(wostream&, const char*);
>
>
>}
># 526 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/ostream" 2 3
># 47 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/istream.tcc" 2 3
>
>namespace std
>{
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>::sentry::
> sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> if (__in.good())
> {
> if (__in.tie())
> __in.tie()->flush();
> if (!__noskip && (__in.flags() & ios_base::skipws))
> {
> const __int_type __eof = traits_type::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> const __ctype_type& __ct = __check_facet(__in._M_ctype);
> while (!traits_type::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space,
> traits_type::to_char_type(__c)))
> __c = __sb->snextc();
>
>
>
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> }
>
> if (__in.good() && __err == ios_base::goodbit)
> _M_ok = true;
> else
> {
> __err |= ios_base::failbit;
> __in.setstate(__err);
> }
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__istream_type& (*__pf)(__istream_type&))
> { return __pf(*this); }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__ios_type& (*__pf)(__ios_type&))
> {
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(ios_base& (*__pf)(ios_base&))
> {
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(bool& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(short& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
> if (!(__err & ios_base::failbit)
> && (numeric_limits<short>::min() <= __l
> && __l <= numeric_limits<short>::max()))
> __n = __l;
> else
> __err |= ios_base::failbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(unsigned short& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(int& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
> if (!(__err & ios_base::failbit)
> && (numeric_limits<int>::min() <= __l
> && __l <= numeric_limits<int>::max()))
> __n = __l;
> else
> __err |= ios_base::failbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(unsigned int& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(unsigned long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(long long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(unsigned long long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(float& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(double& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(long double& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(void*& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__streambuf_type* __sbout)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this, false);
> if (__cerb && __sbout)
> {
> try
> {
> if (!__copy_streambufs(this->rdbuf(), __sbout))
> __err |= ios_base::failbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbout)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> get(void)
> {
> const int_type __eof = traits_type::eof();
> int_type __c = __eof;
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> __c = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__c, __eof))
> _M_gcount = 1;
> else
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type& __c)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __cb = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__cb, traits_type::eof()))
> {
> _M_gcount = 1;
> __c = traits_type::to_char_type(__cb);
> }
> else
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(__streambuf_type& __sb, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __this_sb = this->rdbuf();
> int_type __c = __this_sb->sgetc();
> char_type __c2 = traits_type::to_char_type(__c);
>
> while (!traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim)
> && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
> {
> ++_M_gcount;
> __c = __this_sb->snextc();
> __c2 = traits_type::to_char_type(__c);
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> getline(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> ++_M_gcount;
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else
> {
> if (traits_type::eq_int_type(__c, __idelim))
> {
> __sb->sbumpc();
> ++_M_gcount;
> }
> else
> __err |= ios_base::failbit;
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(void)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
>
> if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
> __err |= ios_base::eofbit;
> else
> _M_gcount = 1;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
># 692 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/istream.tcc" 3
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == numeric_limits<streamsize>::max()
> && !traits_type::eq_int_type(__c, __eof))
> {
> _M_gcount = numeric_limits<streamsize>::min();
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = numeric_limits<streamsize>::max();
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n, int_type __delim)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
>
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == numeric_limits<streamsize>::max()
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> _M_gcount = numeric_limits<streamsize>::min();
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = numeric_limits<streamsize>::max();
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else if (traits_type::eq_int_type(__c, __delim))
> {
> if (_M_gcount < numeric_limits<streamsize>::max())
> ++_M_gcount;
> __sb->sbumpc();
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> peek(void)
> {
> int_type __c = traits_type::eof();
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> __c = this->rdbuf()->sgetc();
> if (traits_type::eq_int_type(__c, traits_type::eof()))
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> read(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> _M_gcount = this->rdbuf()->sgetn(__s, __n);
> if (_M_gcount != __n)
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_istream<_CharT, _Traits>::
> readsome(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
>
> const streamsize __num = this->rdbuf()->in_avail();
> if (__num > 0)
> _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
> else if (__num == -1)
> __err |= ios_base::eofbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return _M_gcount;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> putback(char_type __c)
> {
>
>
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> unget(void)
> {
>
>
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sungetc(), __eof))
> __err |= ios_base::badbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> int
> basic_istream<_CharT, _Traits>::
> sync(void)
> {
>
>
> int __ret = -1;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> __streambuf_type* __sb = this->rdbuf();
> if (__sb)
> {
> if (__sb->pubsync() == -1)
> __err |= ios_base::badbit;
> else
> __ret = 0;
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::pos_type
> basic_istream<_CharT, _Traits>::
> tellg(void)
> {
>
>
> pos_type __ret = pos_type(-1);
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(pos_type __pos)
> {
>
>
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(off_type __off, ios_base::seekdir __dir)
> {
>
>
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::int_type __int_type;
>
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __int_type __cb = __in.rdbuf()->sbumpc();
> if (!_Traits::eq_int_type(__cb, _Traits::eof()))
> __c = _Traits::to_char_type(__cb);
> else
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> if (__err)
> __in.setstate(__err);
> }
> return __in;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename _Traits::int_type int_type;
> typedef _CharT char_type;
> typedef ctype<_CharT> __ctype_type;
>
> streamsize __extracted = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> streamsize __num = __in.width();
> if (__num <= 0)
> __num = numeric_limits<streamsize>::max();
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>
> const int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> int_type __c = __sb->sgetc();
>
> while (__extracted < __num - 1
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> *__s++ = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
>
>
>
> *__s = char_type();
> __in.width(0);
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> }
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT,_Traits>&
> ws(basic_istream<_CharT,_Traits>& __in)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef typename __istream_type::int_type __int_type;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (!_Traits::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
> __c = __sb->snextc();
>
> if (_Traits::eq_int_type(__c, __eof))
> __in.setstate(ios_base::eofbit);
> return __in;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> __str.erase();
> _CharT __buf[128];
> __size_type __len = 0;
> const streamsize __w = __in.width();
> const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
> : __str.max_size();
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
> {
> if (__len == sizeof(__buf) / sizeof(_CharT))
> {
> __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
> __len = 0;
> }
> __buf[__len++] = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
> __str.append(__buf, __len);
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> __in.width(0);
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(ios_base::badbit);
> }
> }
>
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> const __size_type __n = __str.max_size();
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> typename __istream_type::sentry __cerb(__in, true);
> if (__cerb)
> {
> try
> {
> __str.erase();
> const __int_type __idelim = _Traits::to_int_type(__delim);
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !_Traits::eq_int_type(__c, __idelim))
> {
> __str += _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else if (_Traits::eq_int_type(__c, __idelim))
> {
> ++__extracted;
> __sb->sbumpc();
> }
> else
> __err |= ios_base::failbit;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(ios_base::badbit);
> }
> }
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
> template<class _CharT, class _Traits, class _Alloc>
> inline basic_istream<_CharT,_Traits>&
> getline(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT,_Traits,_Alloc>& __str)
> { return getline(__in, __str, __in.widen('\n')); }
>
>
>
>
>
> extern template class basic_istream<char>;
> extern template istream& ws(istream&);
> extern template istream& operator>>(istream&, char&);
> extern template istream& operator>>(istream&, char*);
> extern template istream& operator>>(istream&, unsigned char&);
> extern template istream& operator>>(istream&, signed char&);
> extern template istream& operator>>(istream&, unsigned char*);
> extern template istream& operator>>(istream&, signed char*);
>
> extern template class basic_iostream<char>;
>
>
> extern template class basic_istream<wchar_t>;
> extern template wistream& ws(wistream&);
> extern template wistream& operator>>(wistream&, wchar_t&);
> extern template wistream& operator>>(wistream&, wchar_t*);
>
> extern template class basic_iostream<wchar_t>;
>
>
>}
># 820 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/istream" 2 3
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 2 3
>
>
>namespace std
>{
># 61 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
> typedef basic_string<char_type, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> protected:
>
>
>
>
>
> ios_base::openmode _M_mode;
>
>
> __string_type _M_string;
>
> public:
># 99 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(__mode), _M_string()
> { }
># 112 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_stringbuf(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
> { _M_stringbuf_init(__mode); }
># 127 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> __string_type
> str() const
> {
> __string_type __ret;
> if (this->pptr())
> {
>
> if (this->pptr() > this->egptr())
> __ret = __string_type(this->pbase(), this->pptr());
> else
> __ret = __string_type(this->pbase(), this->egptr());
> }
> else
> __ret = _M_string;
> return __ret;
> }
># 151 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> void
> str(const __string_type& __s)
> {
>
> _M_string.assign(__s.data(), __s.size());
> _M_stringbuf_init(_M_mode);
> }
>
> protected:
>
> void
> _M_stringbuf_init(ios_base::openmode __mode)
> {
> _M_mode = __mode;
> __size_type __len = 0;
> if (_M_mode & (ios_base::ate | ios_base::app))
> __len = _M_string.size();
> _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
> }
>
> virtual streamsize
> showmanyc()
> {
> streamsize __ret = -1;
> if (_M_mode & ios_base::in)
> {
> _M_update_egptr();
> __ret = this->egptr() - this->gptr();
> }
> return __ret;
> }
>
> virtual int_type
> underflow();
>
> virtual int_type
> pbackfail(int_type __c = traits_type::eof());
>
> virtual int_type
> overflow(int_type __c = traits_type::eof());
># 203 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> virtual __streambuf_type*
> setbuf(char_type* __s, streamsize __n)
> {
> if (__s && __n >= 0)
> {
>
>
>
>
>
>
> _M_string.clear();
>
>
> _M_sync(__s, __n, 0);
> }
> return this;
> }
>
> virtual pos_type
> seekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
> virtual pos_type
> seekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
>
>
>
> void
> _M_sync(char_type* __base, __size_type __i, __size_type __o);
>
>
>
> void
> _M_update_egptr()
> {
> const bool __testin = _M_mode & ios_base::in;
> if (this->pptr() && this->pptr() > this->egptr())
> if (__testin)
> this->setg(this->eback(), this->gptr(), this->pptr());
> else
> this->setg(this->pptr(), this->pptr(), this->pptr());
> }
> };
># 260 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_istringstream : public basic_istream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_istream<char_type, traits_type> __istream_type;
>
> private:
> __stringbuf_type _M_stringbuf;
>
> public:
># 298 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_istringstream(ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__mode | ios_base::in)
> { this->init(&_M_stringbuf); }
># 318 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_istringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_istringstream()
> { }
># 340 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 373 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> template <typename _CharT, typename _Traits, typename _Alloc>
> class basic_ostringstream : public basic_ostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_ostream<char_type, traits_type> __ostream_type;
>
> private:
> __stringbuf_type _M_stringbuf;
>
> public:
># 411 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_ostringstream(ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
> { this->init(&_M_stringbuf); }
># 431 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_ostringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_ostringstream()
> { }
># 453 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 486 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> template <typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringstream : public basic_iostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_iostream<char_type, traits_type> __iostream_type;
>
> private:
> __stringbuf_type _M_stringbuf;
>
> public:
># 522 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__m)
> { this->init(&_M_stringbuf); }
># 540 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> explicit
> basic_stringstream(const __string_type& __str,
> ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__str, __m)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_stringstream()
> { }
># 562 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/sstream.tcc" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/sstream.tcc" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/sstream.tcc" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/sstream.tcc" 2 3
>
>namespace std
>{
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> pbackfail(int_type __c)
> {
> int_type __ret = traits_type::eof();
> if (this->eback() < this->gptr())
> {
>
>
> const bool __testeof = traits_type::eq_int_type(__c, __ret);
> if (!__testeof)
> {
> const bool __testeq = traits_type::eq(traits_type::
> to_char_type(__c),
> this->gptr()[-1]);
> const bool __testout = this->_M_mode & ios_base::out;
> if (__testeq || __testout)
> {
> this->gbump(-1);
> if (!__testeq)
> *this->gptr() = traits_type::to_char_type(__c);
> __ret = __c;
> }
> }
> else
> {
> this->gbump(-1);
> __ret = traits_type::not_eof(__c);
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> overflow(int_type __c)
> {
> const bool __testout = this->_M_mode & ios_base::out;
> if (__builtin_expect(!__testout, false))
> return traits_type::eof();
>
> const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
> if (__builtin_expect(__testeof, false))
> return traits_type::not_eof(__c);
>
> const __size_type __capacity = _M_string.capacity();
> const __size_type __max_size = _M_string.max_size();
> const bool __testput = this->pptr() < this->epptr();
> if (__builtin_expect(!__testput && __capacity == __max_size, false))
> return traits_type::eof();
>
>
>
> if (!__testput)
> {
>
>
>
>
>
>
> const __size_type __opt_len = std::max(__size_type(2 * __capacity),
> __size_type(512));
> const __size_type __len = std::min(__opt_len, __max_size);
> __string_type __tmp;
> __tmp.reserve(__len);
> if (this->pbase())
> __tmp.assign(this->pbase(), this->epptr() - this->pbase());
> _M_string.swap(__tmp);
> _M_sync(const_cast<char_type*>(_M_string.data()),
> this->gptr() - this->eback(), this->pptr() - this->pbase());
> }
> return this->sputc(traits_type::to_char_type(__c));
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> underflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testin = this->_M_mode & ios_base::in;
> if (__testin)
> {
>
> _M_update_egptr();
>
> if (this->gptr() < this->egptr())
> __ret = traits_type::to_int_type(*this->gptr());
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
> {
> pos_type __ret = pos_type(off_type(-1));
> bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
> bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
> const bool __testboth = __testin && __testout && __way != ios_base::cur;
> __testin &= !(__mode & ios_base::out);
> __testout &= !(__mode & ios_base::in);
>
>
>
> const char_type* __beg = __testin ? this->eback() : this->pbase();
> if ((__beg || !__off) && (__testin || __testout || __testboth))
> {
> _M_update_egptr();
>
> off_type __newoffi = __off;
> off_type __newoffo = __newoffi;
> if (__way == ios_base::cur)
> {
> __newoffi += this->gptr() - __beg;
> __newoffo += this->pptr() - __beg;
> }
> else if (__way == ios_base::end)
> __newoffo = __newoffi += this->egptr() - __beg;
>
> if ((__testin || __testboth)
> && __newoffi >= 0
> && this->egptr() - __beg >= __newoffi)
> {
> this->gbump((__beg + __newoffi) - this->gptr());
> __ret = pos_type(__newoffi);
> }
> if ((__testout || __testboth)
> && __newoffo >= 0
> && this->egptr() - __beg >= __newoffo)
> {
> this->pbump((__beg + __newoffo) - this->pptr());
> __ret = pos_type(__newoffo);
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> seekpos(pos_type __sp, ios_base::openmode __mode)
> {
> pos_type __ret = pos_type(off_type(-1));
> const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
> const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
>
> const char_type* __beg = __testin ? this->eback() : this->pbase();
> if ((__beg || !off_type(__sp)) && (__testin || __testout))
> {
> _M_update_egptr();
>
> const off_type __pos(__sp);
> const bool __testpos = 0 <= __pos
> && __pos <= this->egptr() - __beg;
> if (__testpos)
> {
> if (__testin)
> this->gbump((__beg + __pos) - this->gptr());
> if (__testout)
> this->pbump((__beg + __pos) - this->pptr());
> __ret = __sp;
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> void
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> _M_sync(char_type* __base, __size_type __i, __size_type __o)
> {
> const bool __testin = _M_mode & ios_base::in;
> const bool __testout = _M_mode & ios_base::out;
> char_type* __endg = __base + _M_string.size();
> char_type* __endp = __base + _M_string.capacity();
>
> if (__base != _M_string.data())
> {
>
> __endg += __i;
> __i = 0;
> __endp = __endg;
> }
>
> if (__testin)
> this->setg(__base, __base + __i, __endg);
> if (__testout)
> {
> this->setp(__base, __endp);
> this->pbump(__o);
>
>
>
> if (!__testin)
> this->setg(__endg, __endg, __endg);
> }
> }
>
>
>
>
>
> extern template class basic_stringbuf<char>;
> extern template class basic_istringstream<char>;
> extern template class basic_ostringstream<char>;
> extern template class basic_stringstream<char>;
>
>
> extern template class basic_stringbuf<wchar_t>;
> extern template class basic_istringstream<wchar_t>;
> extern template class basic_ostringstream<wchar_t>;
> extern template class basic_stringstream<wchar_t>;
>
>
>}
># 588 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/sstream" 2 3
># 11 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/stack" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/stack" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/stack" 3
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/deque" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/deque" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/deque" 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 1 3
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
>namespace std
>{
># 82 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> inline size_t
> __deque_buf_size(size_t __size)
> { return __size < 512 ? size_t(512 / __size) : size_t(1); }
># 100 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _Tp, typename _Ref, typename _Ptr>
> struct _Deque_iterator
> {
> typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
> typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
>
> static size_t _S_buffer_size()
> { return __deque_buf_size(sizeof(_Tp)); }
>
> typedef std::random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef _Ptr pointer;
> typedef _Ref reference;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp** _Map_pointer;
> typedef _Deque_iterator _Self;
>
> _Tp* _M_cur;
> _Tp* _M_first;
> _Tp* _M_last;
> _Map_pointer _M_node;
>
> _Deque_iterator(_Tp* __x, _Map_pointer __y)
> : _M_cur(__x), _M_first(*__y),
> _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
>
> _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
>
> _Deque_iterator(const iterator& __x)
> : _M_cur(__x._M_cur), _M_first(__x._M_first),
> _M_last(__x._M_last), _M_node(__x._M_node) {}
>
> reference
> operator*() const
> { return *_M_cur; }
>
> pointer
> operator->() const
> { return _M_cur; }
>
> _Self&
> operator++()
> {
> ++_M_cur;
> if (_M_cur == _M_last)
> {
> _M_set_node(_M_node + 1);
> _M_cur = _M_first;
> }
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> ++*this;
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> if (_M_cur == _M_first)
> {
> _M_set_node(_M_node - 1);
> _M_cur = _M_last;
> }
> --_M_cur;
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> --*this;
> return __tmp;
> }
>
> _Self&
> operator+=(difference_type __n)
> {
> const difference_type __offset = __n + (_M_cur - _M_first);
> if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
> _M_cur += __n;
> else
> {
> const difference_type __node_offset =
> __offset > 0 ? __offset / difference_type(_S_buffer_size())
> : -difference_type((-__offset - 1)
> / _S_buffer_size()) - 1;
> _M_set_node(_M_node + __node_offset);
> _M_cur = _M_first + (__offset - __node_offset
> * difference_type(_S_buffer_size()));
> }
> return *this;
> }
>
> _Self
> operator+(difference_type __n) const
> {
> _Self __tmp = *this;
> return __tmp += __n;
> }
>
> _Self&
> operator-=(difference_type __n)
> { return *this += -__n; }
>
> _Self
> operator-(difference_type __n) const
> {
> _Self __tmp = *this;
> return __tmp -= __n;
> }
>
> reference
> operator[](difference_type __n) const
> { return *(*this + __n); }
>
>
>
>
>
>
>
> void
> _M_set_node(_Map_pointer __new_node)
> {
> _M_node = __new_node;
> _M_first = *__new_node;
> _M_last = _M_first + difference_type(_S_buffer_size());
> }
> };
>
>
>
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return __x._M_cur == __y._M_cur; }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return __x._M_cur == __y._M_cur; }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return !(__x == __y); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return !(__x == __y); }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
> : (__x._M_node < __y._M_node); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
> : (__x._M_node < __y._M_node); }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return __y < __x; }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return __y < __x; }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return !(__y < __x); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return !(__y < __x); }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return !(__x < __y); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return !(__x < __y); }
>
>
>
>
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
> operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> {
> return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
> (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
> * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
> + (__y._M_last - __y._M_cur);
> }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline _Deque_iterator<_Tp, _Ref, _Ptr>
> operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
> { return __x + __n; }
># 353 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> class _Deque_base
> {
> public:
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return _M_get_Tp_allocator(); }
>
> typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
> typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
>
> _Deque_base(const allocator_type& __a, size_t __num_elements)
> : _M_impl(__a)
> { _M_initialize_map(__num_elements); }
>
> _Deque_base(const allocator_type& __a)
> : _M_impl(__a)
> { }
>
> ~_Deque_base();
>
> protected:
>
>
>
> typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
>
> typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
>
> struct _Deque_impl
> : public _Tp_alloc_type
> {
> _Tp** _M_map;
> size_t _M_map_size;
> iterator _M_start;
> iterator _M_finish;
>
> _Deque_impl(const _Tp_alloc_type& __a)
> : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
> _M_start(), _M_finish()
> { }
> };
>
> _Tp_alloc_type&
> _M_get_Tp_allocator()
> { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
>
> const _Tp_alloc_type&
> _M_get_Tp_allocator() const
> { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
>
> _Map_alloc_type
> _M_get_map_allocator() const
> { return _M_get_Tp_allocator(); }
>
> _Tp*
> _M_allocate_node()
> {
> return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
> }
>
> void
> _M_deallocate_node(_Tp* __p)
> {
> _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
> }
>
> _Tp**
> _M_allocate_map(size_t __n)
> { return _M_get_map_allocator().allocate(__n); }
>
> void
> _M_deallocate_map(_Tp** __p, size_t __n)
> { _M_get_map_allocator().deallocate(__p, __n); }
>
> protected:
> void _M_initialize_map(size_t);
> void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
> void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
> enum { _S_initial_map_size = 8 };
>
> _Deque_impl _M_impl;
> };
>
> template<typename _Tp, typename _Alloc>
> _Deque_base<_Tp, _Alloc>::
> ~_Deque_base()
> {
> if (this->_M_impl._M_map)
> {
> _M_destroy_nodes(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1);
> _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
> }
> }
># 461 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp, _Alloc>::
> _M_initialize_map(size_t __num_elements)
> {
> const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
> + 1);
>
> this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
> size_t(__num_nodes + 2));
> this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
>
>
>
>
>
>
> _Tp** __nstart = (this->_M_impl._M_map
> + (this->_M_impl._M_map_size - __num_nodes) / 2);
> _Tp** __nfinish = __nstart + __num_nodes;
>
> try
> { _M_create_nodes(__nstart, __nfinish); }
> catch(...)
> {
> _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
> this->_M_impl._M_map = 0;
> this->_M_impl._M_map_size = 0;
> throw;
> }
>
> this->_M_impl._M_start._M_set_node(__nstart);
> this->_M_impl._M_finish._M_set_node(__nfinish - 1);
> this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
> this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
> + __num_elements
> % __deque_buf_size(sizeof(_Tp)));
> }
>
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp, _Alloc>::
> _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
> {
> _Tp** __cur;
> try
> {
> for (__cur = __nstart; __cur < __nfinish; ++__cur)
> *__cur = this->_M_allocate_node();
> }
> catch(...)
> {
> _M_destroy_nodes(__nstart, __cur);
> throw;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp, _Alloc>::
> _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
> {
> for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
> _M_deallocate_node(*__n);
> }
># 611 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class deque : protected _Deque_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _Deque_base<_Tp, _Alloc> _Base;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
>
> public:
> typedef _Tp value_type;
> typedef typename _Tp_alloc_type::pointer pointer;
> typedef typename _Tp_alloc_type::const_pointer const_pointer;
> typedef typename _Tp_alloc_type::reference reference;
> typedef typename _Tp_alloc_type::const_reference const_reference;
> typedef typename _Base::iterator iterator;
> typedef typename _Base::const_iterator const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
> typedef pointer* _Map_pointer;
>
> static size_t _S_buffer_size()
> { return __deque_buf_size(sizeof(_Tp)); }
>
>
> using _Base::_M_initialize_map;
> using _Base::_M_create_nodes;
> using _Base::_M_destroy_nodes;
> using _Base::_M_allocate_node;
> using _Base::_M_deallocate_node;
> using _Base::_M_allocate_map;
> using _Base::_M_deallocate_map;
> using _Base::_M_get_Tp_allocator;
>
>
>
>
>
>
> using _Base::_M_impl;
>
> public:
>
>
>
>
>
> explicit
> deque(const allocator_type& __a = allocator_type())
> : _Base(__a, 0) {}
># 676 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> explicit
> deque(size_type __n, const value_type& __value = value_type(),
> const allocator_type& __a = allocator_type())
> : _Base(__a, __n)
> { _M_fill_initialize(__value); }
># 689 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> deque(const deque& __x)
> : _Base(__x.get_allocator(), __x.size())
> { std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator()); }
># 709 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _InputIterator>
> deque(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
>
>
>
>
>
> ~deque()
> { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator()); }
># 735 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> deque&
> operator=(const deque& __x);
># 748 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 764 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> allocator_type
> get_allocator() const
> { return _Base::get_allocator(); }
>
>
>
>
>
>
> iterator
> begin()
> { return this->_M_impl._M_start; }
>
>
>
>
>
> const_iterator
> begin() const
> { return this->_M_impl._M_start; }
>
>
>
>
>
>
> iterator
> end()
> { return this->_M_impl._M_finish; }
>
>
>
>
>
>
> const_iterator
> end() const
> { return this->_M_impl._M_finish; }
>
>
>
>
>
>
> reverse_iterator
> rbegin()
> { return reverse_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const
> { return const_reverse_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> reverse_iterator
> rend() { return reverse_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const
> { return const_reverse_iterator(this->_M_impl._M_start); }
>
>
>
> size_type
> size() const
> { return this->_M_impl._M_finish - this->_M_impl._M_start; }
>
>
> size_type
> max_size() const
> { return size_type(-1); }
># 869 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> resize(size_type __new_size, value_type __x = value_type())
> {
> const size_type __len = size();
> if (__new_size < __len)
> erase(this->_M_impl._M_start + __new_size, this->_M_impl._M_finish);
> else
> insert(this->_M_impl._M_finish, __new_size - __len, __x);
> }
>
>
>
>
>
> bool
> empty() const
> { return this->_M_impl._M_finish == this->_M_impl._M_start; }
># 899 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> reference
> operator[](size_type __n)
> { return this->_M_impl._M_start[difference_type(__n)]; }
># 914 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> const_reference
> operator[](size_type __n) const
> { return this->_M_impl._M_start[difference_type(__n)]; }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("deque::_M_range_check"));
> }
>
> public:
># 939 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> reference
> at(size_type __n)
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
># 957 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> {
> iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
>
>
>
>
>
> const_reference
> back() const
> {
> const_iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
># 1014 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> push_front(const value_type& __x)
> {
> if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
> {
> this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
> --this->_M_impl._M_start._M_cur;
> }
> else
> _M_push_front_aux(__x);
> }
># 1035 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> push_back(const value_type& __x)
> {
> if (this->_M_impl._M_finish._M_cur
> != this->_M_impl._M_finish._M_last - 1)
> {
> this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
> ++this->_M_impl._M_finish._M_cur;
> }
> else
> _M_push_back_aux(__x);
> }
># 1056 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> pop_front()
> {
> if (this->_M_impl._M_start._M_cur
> != this->_M_impl._M_start._M_last - 1)
> {
> this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
> ++this->_M_impl._M_start._M_cur;
> }
> else
> _M_pop_front_aux();
> }
># 1077 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> pop_back()
> {
> if (this->_M_impl._M_finish._M_cur
> != this->_M_impl._M_finish._M_first)
> {
> --this->_M_impl._M_finish._M_cur;
> this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
> }
> else
> _M_pop_back_aux();
> }
># 1099 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> iterator
> insert(iterator position, const value_type& __x);
># 1111 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 1125 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 1148 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> iterator
> erase(iterator __position);
># 1167 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 1179 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> swap(deque& __x)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
> std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
> }
>
>
>
>
>
>
>
> void clear();
>
> protected:
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize_map(__n);
> _M_fill_initialize(__x);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
># 1233 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag);
># 1257 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> _M_fill_initialize(const value_type& __value);
>
>
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> {
> _M_fill_assign(static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len > size())
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> else
> erase(std::copy(__first, __last, begin()), end());
> }
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val)
> {
> if (__n > size())
> {
> std::fill(begin(), end(), __val);
> insert(end(), __n - size(), __val);
> }
> else
> {
> erase(begin() + __n, end());
> std::fill(begin(), end(), __val);
> }
> }
>
>
>
>
>
>
>
> void _M_push_back_aux(const value_type&);
> void _M_push_front_aux(const value_type&);
> void _M_pop_back_aux();
> void _M_pop_front_aux();
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos,
> _Integer __n, _Integer __x, __true_type)
> {
> _M_fill_insert(__pos, static_cast<size_type>(__n),
> static_cast<value_type>(__x));
> }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_insert_aux(__pos, __first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_insert_aux(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
> iterator
> _M_insert_aux(iterator __pos, const value_type& __x);
>
>
> void
> _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
>
>
> template<typename _ForwardIterator>
> void
> _M_insert_aux(iterator __pos,
> _ForwardIterator __first, _ForwardIterator __last,
> size_type __n);
># 1401 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> iterator
> _M_reserve_elements_at_front(size_type __n)
> {
> const size_type __vacancies = this->_M_impl._M_start._M_cur
> - this->_M_impl._M_start._M_first;
> if (__n > __vacancies)
> _M_new_elements_at_front(__n - __vacancies);
> return this->_M_impl._M_start - difference_type(__n);
> }
>
> iterator
> _M_reserve_elements_at_back(size_type __n)
> {
> const size_type __vacancies = (this->_M_impl._M_finish._M_last
> - this->_M_impl._M_finish._M_cur) - 1;
> if (__n > __vacancies)
> _M_new_elements_at_back(__n - __vacancies);
> return this->_M_impl._M_finish + difference_type(__n);
> }
>
> void
> _M_new_elements_at_front(size_type __new_elements);
>
> void
> _M_new_elements_at_back(size_type __new_elements);
># 1439 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> void
> _M_reserve_map_at_back (size_type __nodes_to_add = 1)
> {
> if (__nodes_to_add + 1 > this->_M_impl._M_map_size
> - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
> _M_reallocate_map(__nodes_to_add, false);
> }
>
> void
> _M_reserve_map_at_front (size_type __nodes_to_add = 1)
> {
> if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
> - this->_M_impl._M_map))
> _M_reallocate_map(__nodes_to_add, true);
> }
>
> void
> _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
>
> };
># 1471 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return __x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin()); }
># 1489 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
> { __x.swap(__y); }
>}
># 71 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/deque" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/deque.tcc" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/deque.tcc" 3
>namespace std
>{
> template <typename _Tp, typename _Alloc>
> deque<_Tp, _Alloc>&
> deque<_Tp, _Alloc>::
> operator=(const deque& __x)
> {
> const size_type __len = size();
> if (&__x != this)
> {
> if (__len >= __x.size())
> erase(std::copy(__x.begin(), __x.end(), this->_M_impl._M_start),
> this->_M_impl._M_finish);
> else
> {
> const_iterator __mid = __x.begin() + difference_type(__len);
> std::copy(__x.begin(), __mid, this->_M_impl._M_start);
> insert(this->_M_impl._M_finish, __mid, __x.end());
> }
> }
> return *this;
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> insert(iterator position, const value_type& __x)
> {
> if (position._M_cur == this->_M_impl._M_start._M_cur)
> {
> push_front(__x);
> return this->_M_impl._M_start;
> }
> else if (position._M_cur == this->_M_impl._M_finish._M_cur)
> {
> push_back(__x);
> iterator __tmp = this->_M_impl._M_finish;
> --__tmp;
> return __tmp;
> }
> else
> return _M_insert_aux(position, __x);
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> erase(iterator __position)
> {
> iterator __next = __position;
> ++__next;
> const size_type __index = __position - this->_M_impl._M_start;
> if (__index < (size() >> 1))
> {
> std::copy_backward(this->_M_impl._M_start, __position, __next);
> pop_front();
> }
> else
> {
> std::copy(__next, this->_M_impl._M_finish, __position);
> pop_back();
> }
> return this->_M_impl._M_start + __index;
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> if (__first == this->_M_impl._M_start
> && __last == this->_M_impl._M_finish)
> {
> clear();
> return this->_M_impl._M_finish;
> }
> else
> {
> const difference_type __n = __last - __first;
> const difference_type __elems_before = (__first
> - this->_M_impl._M_start);
> if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
> {
> std::copy_backward(this->_M_impl._M_start, __first, __last);
> iterator __new_start = this->_M_impl._M_start + __n;
> std::_Destroy(this->_M_impl._M_start, __new_start,
> _M_get_Tp_allocator());
> _M_destroy_nodes(this->_M_impl._M_start._M_node,
> __new_start._M_node);
> this->_M_impl._M_start = __new_start;
> }
> else
> {
> std::copy(__last, this->_M_impl._M_finish, __first);
> iterator __new_finish = this->_M_impl._M_finish - __n;
> std::_Destroy(__new_finish, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_destroy_nodes(__new_finish._M_node + 1,
> this->_M_impl._M_finish._M_node + 1);
> this->_M_impl._M_finish = __new_finish;
> }
> return this->_M_impl._M_start + __elems_before;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> clear()
> {
> for (_Map_pointer __node = this->_M_impl._M_start._M_node + 1;
> __node < this->_M_impl._M_finish._M_node;
> ++__node)
> {
> std::_Destroy(*__node, *__node + _S_buffer_size(),
> _M_get_Tp_allocator());
> _M_deallocate_node(*__node);
> }
>
> if (this->_M_impl._M_start._M_node != this->_M_impl._M_finish._M_node)
> {
> std::_Destroy(this->_M_impl._M_start._M_cur,
> this->_M_impl._M_start._M_last,
> _M_get_Tp_allocator());
> std::_Destroy(this->_M_impl._M_finish._M_first,
> this->_M_impl._M_finish._M_cur,
> _M_get_Tp_allocator());
> _M_deallocate_node(this->_M_impl._M_finish._M_first);
> }
> else
> std::_Destroy(this->_M_impl._M_start._M_cur,
> this->_M_impl._M_finish._M_cur,
> _M_get_Tp_allocator());
>
> this->_M_impl._M_finish = this->_M_impl._M_start;
> }
>
> template <typename _Tp, class _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp, _Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur = begin();
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> erase(__cur, end());
> else
> insert(end(), __first, __last);
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
> {
> if (__pos._M_cur == this->_M_impl._M_start._M_cur)
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> try
> {
> std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
> __x,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> try
> {
> std::__uninitialized_fill_a(this->_M_impl._M_finish,
> __new_finish, __x,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> else
> _M_insert_aux(__pos, __n, __x);
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_fill_initialize(const value_type& __value)
> {
> _Map_pointer __cur;
> try
> {
> for (__cur = this->_M_impl._M_start._M_node;
> __cur < this->_M_impl._M_finish._M_node;
> ++__cur)
> std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
> __value, _M_get_Tp_allocator());
> std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
> this->_M_impl._M_finish._M_cur,
> __value, _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
> _M_get_Tp_allocator());
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_initialize(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> this->_M_initialize_map(0);
> try
> {
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
> catch(...)
> {
> clear();
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _ForwardIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> this->_M_initialize_map(__n);
>
> _Map_pointer __cur_node;
> try
> {
> for (__cur_node = this->_M_impl._M_start._M_node;
> __cur_node < this->_M_impl._M_finish._M_node;
> ++__cur_node)
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, _S_buffer_size());
> std::__uninitialized_copy_a(__first, __mid, *__cur_node,
> _M_get_Tp_allocator());
> __first = __mid;
> }
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_finish._M_first,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start,
> iterator(*__cur_node, __cur_node),
> _M_get_Tp_allocator());
> throw;
> }
> }
>
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_push_back_aux(const value_type& __t)
> {
> value_type __t_copy = __t;
> _M_reserve_map_at_back();
> *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
> try
> {
> this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t_copy);
> this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
> + 1);
> this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
> }
> catch(...)
> {
> _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
> throw;
> }
> }
>
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_push_front_aux(const value_type& __t)
> {
> value_type __t_copy = __t;
> _M_reserve_map_at_front();
> *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
> try
> {
> this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
> - 1);
> this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
> this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t_copy);
> }
> catch(...)
> {
> ++this->_M_impl._M_start;
> _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
> throw;
> }
> }
>
>
> template <typename _Tp, typename _Alloc>
> void deque<_Tp, _Alloc>::
> _M_pop_back_aux()
> {
> _M_deallocate_node(this->_M_impl._M_finish._M_first);
> this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
> this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
> this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
> }
>
>
>
>
>
>
> template <typename _Tp, typename _Alloc>
> void deque<_Tp, _Alloc>::
> _M_pop_front_aux()
> {
> this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
> _M_deallocate_node(this->_M_impl._M_start._M_first);
> this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
> this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_insert_aux(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> { std::copy(__first, __last, std::inserter(*this, __pos)); }
>
> template <typename _Tp, typename _Alloc>
> template <typename _ForwardIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_insert_aux(iterator __pos,
> _ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> if (__pos._M_cur == this->_M_impl._M_start._M_cur)
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last, __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> else
> _M_insert_aux(__pos, __first, __last, __n);
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> _M_insert_aux(iterator __pos, const value_type& __x)
> {
> difference_type __index = __pos - this->_M_impl._M_start;
> value_type __x_copy = __x;
> if (static_cast<size_type>(__index) < size() / 2)
> {
> push_front(front());
> iterator __front1 = this->_M_impl._M_start;
> ++__front1;
> iterator __front2 = __front1;
> ++__front2;
> __pos = this->_M_impl._M_start + __index;
> iterator __pos1 = __pos;
> ++__pos1;
> std::copy(__front2, __pos1, __front1);
> }
> else
> {
> push_back(back());
> iterator __back1 = this->_M_impl._M_finish;
> --__back1;
> iterator __back2 = __back1;
> --__back2;
> __pos = this->_M_impl._M_start + __index;
> std::copy_backward(__pos, __back2, __back1);
> }
> *__pos = __x_copy;
> return __pos;
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
> {
> const difference_type __elems_before = __pos - this->_M_impl._M_start;
> const size_type __length = this->size();
> value_type __x_copy = __x;
> if (__elems_before < difference_type(__length / 2))
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> iterator __old_start = this->_M_impl._M_start;
> __pos = this->_M_impl._M_start + __elems_before;
> try
> {
> if (__elems_before >= difference_type(__n))
> {
> iterator __start_n = (this->_M_impl._M_start
> + difference_type(__n));
> std::__uninitialized_copy_a(this->_M_impl._M_start,
> __start_n, __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::copy(__start_n, __pos, __old_start);
> fill(__pos - difference_type(__n), __pos, __x_copy);
> }
> else
> {
> std::__uninitialized_copy_fill(this->_M_impl._M_start,
> __pos, __new_start,
> this->_M_impl._M_start,
> __x_copy,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::fill(__old_start, __pos, __x_copy);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> iterator __old_finish = this->_M_impl._M_finish;
> const difference_type __elems_after =
> difference_type(__length) - __elems_before;
> __pos = this->_M_impl._M_finish - __elems_after;
> try
> {
> if (__elems_after > difference_type(__n))
> {
> iterator __finish_n = (this->_M_impl._M_finish
> - difference_type(__n));
> std::__uninitialized_copy_a(__finish_n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::copy_backward(__pos, __finish_n, __old_finish);
> std::fill(__pos, __pos + difference_type(__n), __x_copy);
> }
> else
> {
> std::__uninitialized_fill_copy(this->_M_impl._M_finish,
> __pos + difference_type(__n),
> __x_copy, __pos,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::fill(__pos, __old_finish, __x_copy);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _ForwardIterator>
> void
> deque<_Tp, _Alloc>::
> _M_insert_aux(iterator __pos,
> _ForwardIterator __first, _ForwardIterator __last,
> size_type __n)
> {
> const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
> const size_type __length = size();
> if (static_cast<size_type>(__elemsbefore) < __length / 2)
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> iterator __old_start = this->_M_impl._M_start;
> __pos = this->_M_impl._M_start + __elemsbefore;
> try
> {
> if (__elemsbefore >= difference_type(__n))
> {
> iterator __start_n = (this->_M_impl._M_start
> + difference_type(__n));
> std::__uninitialized_copy_a(this->_M_impl._M_start,
> __start_n, __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::copy(__start_n, __pos, __old_start);
> std::copy(__first, __last, __pos - difference_type(__n));
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, difference_type(__n) - __elemsbefore);
> std::__uninitialized_copy_copy(this->_M_impl._M_start,
> __pos, __first, __mid,
> __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::copy(__mid, __last, __old_start);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> iterator __old_finish = this->_M_impl._M_finish;
> const difference_type __elemsafter =
> difference_type(__length) - __elemsbefore;
> __pos = this->_M_impl._M_finish - __elemsafter;
> try
> {
> if (__elemsafter > difference_type(__n))
> {
> iterator __finish_n = (this->_M_impl._M_finish
> - difference_type(__n));
> std::__uninitialized_copy_a(__finish_n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::copy_backward(__pos, __finish_n, __old_finish);
> std::copy(__first, __last, __pos);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elemsafter);
> std::__uninitialized_copy_copy(__mid, __last, __pos,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::copy(__first, __mid, __pos);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_new_elements_at_front(size_type __new_elems)
> {
> const size_type __new_nodes
> = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
> _M_reserve_map_at_front(__new_nodes);
> size_type __i;
> try
> {
> for (__i = 1; __i <= __new_nodes; ++__i)
> *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
> }
> catch(...)
> {
> for (size_type __j = 1; __j < __i; ++__j)
> _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_new_elements_at_back(size_type __new_elems)
> {
> const size_type __new_nodes
> = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
> _M_reserve_map_at_back(__new_nodes);
> size_type __i;
> try
> {
> for (__i = 1; __i <= __new_nodes; ++__i)
> *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
> }
> catch(...)
> {
> for (size_type __j = 1; __j < __i; ++__j)
> _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
> {
> const size_type __old_num_nodes
> = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
> const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
>
> _Map_pointer __new_nstart;
> if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
> {
> __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
> - __new_num_nodes) / 2
> + (__add_at_front ? __nodes_to_add : 0);
> if (__new_nstart < this->_M_impl._M_start._M_node)
> std::copy(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1,
> __new_nstart);
> else
> std::copy_backward(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1,
> __new_nstart + __old_num_nodes);
> }
> else
> {
> size_type __new_map_size = this->_M_impl._M_map_size
> + std::max(this->_M_impl._M_map_size,
> __nodes_to_add) + 2;
>
> _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
> __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
> + (__add_at_front ? __nodes_to_add : 0);
> std::copy(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1,
> __new_nstart);
> _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
>
> this->_M_impl._M_map = __new_map;
> this->_M_impl._M_map_size = __new_map_size;
> }
>
> this->_M_impl._M_start._M_set_node(__new_nstart);
> this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
> }
>}
># 74 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/deque" 2 3
># 70 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/stack" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 3
>namespace std
>{
>
>
> template<typename _Tp, typename _Sequence = deque<_Tp> >
> class stack;
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
># 109 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 3
> template<typename _Tp, typename _Sequence>
> class stack
> {
>
> typedef typename _Sequence::value_type _Sequence_value_type;
> 
> 
> 
>
> template<typename _Tp1, typename _Seq1>
> friend bool
> operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
>
> template<typename _Tp1, typename _Seq1>
> friend bool
> operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
>
> public:
> typedef typename _Sequence::value_type value_type;
> typedef typename _Sequence::reference reference;
> typedef typename _Sequence::const_reference const_reference;
> typedef typename _Sequence::size_type size_type;
> typedef _Sequence container_type;
>
> protected:
>
> _Sequence c;
>
> public:
>
>
>
>
> explicit
> stack(const _Sequence& __c = _Sequence())
> : c(__c) {}
>
>
>
>
> bool
> empty() const
> { return c.empty(); }
>
>
> size_type
> size() const
> { return c.size(); }
>
>
>
>
>
> reference
> top()
> {
> ;
> return c.back();
> }
>
>
>
>
>
> const_reference
> top() const
> {
> ;
> return c.back();
> }
># 189 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 3
> void
> push(const value_type& __x)
> { c.push_back(__x); }
># 204 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 3
> void
> pop()
> {
> ;
> c.pop_back();
> }
> };
># 224 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 3
> template<typename _Tp, typename _Seq>
> inline bool
> operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return __x.c == __y.c; }
># 242 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_stack.h" 3
> template<typename _Tp, typename _Seq>
> inline bool
> operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return __x.c < __y.c; }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return !(__x < __y); }
>}
># 71 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/stack" 2 3
># 12 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/vector" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/vector" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/vector" 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 1 3
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
>namespace std
>{
>
>
>
>
>
> template<typename _Tp, typename _Alloc>
> struct _Vector_base
> {
> typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
>
> struct _Vector_impl
> : public _Tp_alloc_type
> {
> _Tp* _M_start;
> _Tp* _M_finish;
> _Tp* _M_end_of_storage;
> _Vector_impl(_Tp_alloc_type const& __a)
> : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Tp_alloc_type&
> _M_get_Tp_allocator()
> { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
>
> const _Tp_alloc_type&
> _M_get_Tp_allocator() const
> { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const
> { return _M_get_Tp_allocator(); }
>
> _Vector_base(const allocator_type& __a)
> : _M_impl(__a)
> { }
>
> _Vector_base(size_t __n, const allocator_type& __a)
> : _M_impl(__a)
> {
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_finish = this->_M_impl._M_start;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
>
> ~_Vector_base()
> { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start); }
>
> public:
> _Vector_impl _M_impl;
>
> _Tp*
> _M_allocate(size_t __n)
> { return _M_impl.allocate(__n); }
>
> void
> _M_deallocate(_Tp* __p, size_t __n)
> {
> if (__p)
> _M_impl.deallocate(__p, __n);
> }
> };
># 157 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class vector : protected _Vector_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _Vector_base<_Tp, _Alloc> _Base;
> typedef vector<_Tp, _Alloc> vector_type;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
>
> public:
> typedef _Tp value_type;
> typedef typename _Tp_alloc_type::pointer pointer;
> typedef typename _Tp_alloc_type::const_pointer const_pointer;
> typedef typename _Tp_alloc_type::reference reference;
> typedef typename _Tp_alloc_type::const_reference const_reference;
> typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
>
>
>
>
>
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_M_impl;
> using _Base::_M_get_Tp_allocator;
>
> public:
>
>
>
>
>
> explicit
> vector(const allocator_type& __a = allocator_type())
> : _Base(__a)
> { }
># 213 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> explicit
> vector(size_type __n, const value_type& __value = value_type(),
> const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> {
> std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_start + __n;
> }
># 232 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> vector(const vector& __x)
> : _Base(__x.size(), __x.get_allocator())
> { this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
># 255 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> template<typename _InputIterator>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
>
>
>
>
>
>
> ~vector()
> { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
># 284 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> vector&
> operator=(const vector& __x);
># 297 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 313 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> using _Base::get_allocator;
>
>
>
>
>
>
>
> iterator
> begin()
> { return iterator (this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> begin() const
> { return const_iterator (this->_M_impl._M_start); }
>
>
>
>
>
>
> iterator
> end()
> { return iterator (this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_iterator
> end() const
> { return const_iterator (this->_M_impl._M_finish); }
>
>
>
>
>
>
> reverse_iterator
> rbegin()
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend()
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const
> { return const_reverse_iterator(begin()); }
>
>
>
> size_type
> size() const
> { return size_type(end() - begin()); }
>
>
> size_type
> max_size() const
> { return size_type(-1) / sizeof(value_type); }
># 420 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> resize(size_type __new_size, value_type __x = value_type())
> {
> if (__new_size < size())
> erase(begin() + __new_size, end());
> else
> insert(end(), __new_size - size(), __x);
> }
>
>
>
>
>
> size_type
> capacity() const
> { return size_type(const_iterator(this->_M_impl._M_end_of_storage)
> - begin()); }
>
>
>
>
>
> bool
> empty() const
> { return begin() == end(); }
># 463 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> reserve(size_type __n);
># 478 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> reference
> operator[](size_type __n)
> { return *(begin() + __n); }
># 493 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> const_reference
> operator[](size_type __n) const
> { return *(begin() + __n); }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector::_M_range_check"));
> }
>
> public:
># 518 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> reference
> at(size_type __n)
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
># 536 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> { return *(end() - 1); }
>
>
>
>
>
> const_reference
> back() const
> { return *(end() - 1); }
># 582 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> pointer
> data()
> { return pointer(this->_M_impl._M_start); }
>
> const_pointer
> data() const
> { return const_pointer(this->_M_impl._M_start); }
># 601 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> push_back(const value_type& __x)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> this->_M_impl.construct(this->_M_impl._M_finish, __x);
> ++this->_M_impl._M_finish;
> }
> else
> _M_insert_aux(end(), __x);
> }
># 622 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> pop_back()
> {
> --this->_M_impl._M_finish;
> this->_M_impl.destroy(this->_M_impl._M_finish);
> }
># 640 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 656 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 674 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 699 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> iterator
> erase(iterator __position);
># 720 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 732 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> void
> swap(vector& __x)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_end_of_storage,
> __x._M_impl._M_end_of_storage);
> }
>
>
>
>
>
>
>
> void
> clear()
> {
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_start;
> }
>
> protected:
>
>
>
>
>
>
> template<typename _ForwardIterator>
> pointer
> _M_allocate_and_copy(size_type __n,
> _ForwardIterator __first, _ForwardIterator __last)
> {
> pointer __result = this->_M_allocate(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last, __result,
> _M_get_Tp_allocator());
> return __result;
> }
> catch(...)
> {
> _M_deallocate(__result, __n);
> throw;
> }
> }
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
> {
> this->_M_impl._M_start = _M_allocate(__n);
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> {
> _M_fill_assign(static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
> __true_type)
> {
> _M_fill_insert(__pos, static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos, _InputIterator __first,
> _InputIterator __last, __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_insert(__pos, __first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
> void
> _M_insert_aux(iterator __position, const value_type& __x);
> };
># 930 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return (__x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin())); }
># 947 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
> { __x.swap(__y); }
>}
># 71 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/vector" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_bvector.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_bvector.h" 3
>namespace std
>{
> typedef unsigned long _Bit_type;
> enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
>
> struct _Bit_reference
> {
> _Bit_type * _M_p;
> _Bit_type _M_mask;
>
> _Bit_reference(_Bit_type * __x, _Bit_type __y)
> : _M_p(__x), _M_mask(__y) { }
>
> _Bit_reference() : _M_p(0), _M_mask(0) { }
>
> operator bool() const
> { return !!(*_M_p & _M_mask); }
>
> _Bit_reference&
> operator=(bool __x)
> {
> if (__x)
> *_M_p |= _M_mask;
> else
> *_M_p &= ~_M_mask;
> return *this;
> }
>
> _Bit_reference&
> operator=(const _Bit_reference& __x)
> { return *this = bool(__x); }
>
> bool
> operator==(const _Bit_reference& __x) const
> { return bool(*this) == bool(__x); }
>
> bool
> operator<(const _Bit_reference& __x) const
> { return !bool(*this) && bool(__x); }
>
> void
> flip()
> { *_M_p ^= _M_mask; }
> };
>
> struct _Bit_iterator_base
> : public std::iterator<std::random_access_iterator_tag, bool>
> {
> _Bit_type * _M_p;
> unsigned int _M_offset;
>
> _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
> : _M_p(__x), _M_offset(__y) { }
>
> void
> _M_bump_up()
> {
> if (_M_offset++ == int(_S_word_bit) - 1)
> {
> _M_offset = 0;
> ++_M_p;
> }
> }
>
> void
> _M_bump_down()
> {
> if (_M_offset-- == 0)
> {
> _M_offset = int(_S_word_bit) - 1;
> --_M_p;
> }
> }
>
> void
> _M_incr(ptrdiff_t __i)
> {
> difference_type __n = __i + _M_offset;
> _M_p += __n / int(_S_word_bit);
> __n = __n % int(_S_word_bit);
> if (__n < 0)
> {
> _M_offset = static_cast<unsigned int>(__n + int(_S_word_bit));
> --_M_p;
> }
> else
> _M_offset = static_cast<unsigned int>(__n);
> }
>
> bool
> operator==(const _Bit_iterator_base& __i) const
> { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
>
> bool
> operator<(const _Bit_iterator_base& __i) const
> {
> return _M_p < __i._M_p
> || (_M_p == __i._M_p && _M_offset < __i._M_offset);
> }
>
> bool
> operator!=(const _Bit_iterator_base& __i) const
> { return !(*this == __i); }
>
> bool
> operator>(const _Bit_iterator_base& __i) const
> { return __i < *this; }
>
> bool
> operator<=(const _Bit_iterator_base& __i) const
> { return !(__i < *this); }
>
> bool
> operator>=(const _Bit_iterator_base& __i) const
> { return !(*this < __i); }
> };
>
> inline ptrdiff_t
> operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
> {
> return (int(_S_word_bit) * (__x._M_p - __y._M_p)
> + __x._M_offset - __y._M_offset);
> }
>
> struct _Bit_iterator : public _Bit_iterator_base
> {
> typedef _Bit_reference reference;
> typedef _Bit_reference* pointer;
> typedef _Bit_iterator iterator;
>
> _Bit_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> reference
> operator*() const
> { return reference(_M_p, 1UL << _M_offset); }
>
> iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> iterator
> operator++(int)
> {
> iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> iterator
> operator--(int)
> {
> iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> iterator
> operator+(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp += __i;
> }
>
> iterator
> operator-(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_iterator
> operator+(ptrdiff_t __n, const _Bit_iterator& __x)
> { return __x + __n; }
>
> struct _Bit_const_iterator : public _Bit_iterator_base
> {
> typedef bool reference;
> typedef bool const_reference;
> typedef const bool* pointer;
> typedef _Bit_const_iterator const_iterator;
>
> _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> _Bit_const_iterator(const _Bit_iterator& __x)
> : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
>
> const_reference
> operator*() const
> { return _Bit_reference(_M_p, 1UL << _M_offset); }
>
> const_iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> const_iterator
> operator++(int)
> {
> const_iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> const_iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> const_iterator
> operator--(int)
> {
> const_iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> const_iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> const_iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> const_iterator
> operator+(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp += __i;
> }
>
> const_iterator
> operator-(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> const_reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_const_iterator
> operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
> { return __x + __n; }
>
> template<class _Alloc>
> class _Bvector_base
> {
> typedef typename _Alloc::template rebind<_Bit_type>::other
> _Bit_alloc_type;
>
> struct _Bvector_impl : public _Bit_alloc_type
> {
> _Bit_iterator _M_start;
> _Bit_iterator _M_finish;
> _Bit_type* _M_end_of_storage;
> _Bvector_impl(const _Bit_alloc_type& __a)
> : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
> { }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
>
> _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }
>
> ~_Bvector_base()
> { this->_M_deallocate(); }
>
> protected:
> _Bvector_impl _M_impl;
>
> _Bit_type*
> _M_allocate(size_t __n)
> { return _M_impl.allocate((__n + int(_S_word_bit) - 1)
> / int(_S_word_bit)); }
>
> void
> _M_deallocate()
> {
> if (_M_impl._M_start._M_p)
> _M_impl.deallocate(_M_impl._M_start._M_p,
> _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
> }
> };
>}
>
>
>
>
>namespace std
>{
># 425 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_bvector.h" 3
>template<typename _Alloc>
> class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
> {
> public:
> typedef bool value_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Bit_reference reference;
> typedef bool const_reference;
> typedef _Bit_reference* pointer;
> typedef const bool* const_pointer;
>
> typedef _Bit_iterator iterator;
> typedef _Bit_const_iterator const_iterator;
>
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
>
> typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
>
> allocator_type get_allocator() const
> { return _Bvector_base<_Alloc>::get_allocator(); }
>
> protected:
> using _Bvector_base<_Alloc>::_M_allocate;
> using _Bvector_base<_Alloc>::_M_deallocate;
>
> protected:
> void
> _M_initialize(size_type __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = (__q
> + ((__n + int(_S_word_bit) - 1)
> / int(_S_word_bit)));
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
> }
>
> void
> _M_insert_aux(iterator __position, bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
> {
> std::copy_backward(__position, this->_M_impl._M_finish,
> this->_M_impl._M_finish + 1);
> *__position = __x;
> ++this->_M_impl._M_finish;
> }
> else
> {
> const size_type __len = size() ? 2 * size()
> : static_cast<size_type>(_S_word_bit);
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = std::copy(begin(), __position, iterator(__q, 0));
> *__i++ = __x;
> this->_M_impl._M_finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = (__q + ((__len
> + int(_S_word_bit) - 1)
> / int(_S_word_bit)));
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
> template<class _InputIterator>
> void
> _M_initialize_range(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> this->_M_impl._M_start = iterator();
> this->_M_impl._M_finish = iterator();
> this->_M_impl._M_end_of_storage = 0;
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
>
> template<class _ForwardIterator>
> void
> _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> _M_initialize(__n);
> std::copy(__first, __last, this->_M_impl._M_start);
> }
>
> template<class _InputIterator>
> void
> _M_insert_range(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<class _ForwardIterator>
> void
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> size_type __n = std::distance(__first, __last);
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish
> + difference_type(__n));
> std::copy(__first, __last, __position);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len = size() + std::max(size(), __n);
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = std::copy(begin(), __position,
> iterator(__q, 0));
> __i = std::copy(__first, __last, __i);
> this->_M_impl._M_finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = (__q
> + ((__len
> + int(_S_word_bit) - 1)
> / int(_S_word_bit)));
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
> }
>
> public:
> iterator
> begin()
> { return this->_M_impl._M_start; }
>
> const_iterator
> begin() const
> { return this->_M_impl._M_start; }
>
> iterator
> end()
> { return this->_M_impl._M_finish; }
>
> const_iterator
> end() const
> { return this->_M_impl._M_finish; }
>
> reverse_iterator
> rbegin()
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend()
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const
> { return const_reverse_iterator(begin()); }
>
> size_type
> size() const
> { return size_type(end() - begin()); }
>
> size_type
> max_size() const
> { return size_type(-1); }
>
> size_type
> capacity() const
> { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
> - begin()); }
> bool
> empty() const
> { return begin() == end(); }
>
> reference
> operator[](size_type __n)
> { return *(begin() + difference_type(__n)); }
>
> const_reference
> operator[](size_type __n) const
> { return *(begin() + difference_type(__n)); }
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector<bool>::_M_range_check"));
> }
>
> reference
> at(size_type __n)
> { _M_range_check(__n); return (*this)[__n]; }
>
> const_reference
> at(size_type __n) const
> { _M_range_check(__n); return (*this)[__n]; }
>
> explicit
> vector(const allocator_type& __a = allocator_type())
> : _Bvector_base<_Alloc>(__a) { }
>
> vector(size_type __n, bool __value,
> const allocator_type& __a = allocator_type())
> : _Bvector_base<_Alloc>(__a)
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
> __value ? ~0 : 0);
> }
>
> explicit
> vector(size_type __n)
> : _Bvector_base<_Alloc>(allocator_type())
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, 0);
> }
>
> vector(const vector& __x)
> : _Bvector_base<_Alloc>(__x.get_allocator())
> {
> _M_initialize(__x.size());
> std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
> }
>
>
> template<class _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
>
> template<class _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_initialize_range(__first, __last,
> std::__iterator_category(__first)); }
>
> template<class _InputIterator>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Bvector_base<_Alloc>(__a)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
> ~vector() { }
>
> vector&
> operator=(const vector& __x)
> {
> if (&__x == this)
> return *this;
> if (__x.size() > capacity())
> {
> this->_M_deallocate();
> _M_initialize(__x.size());
> }
> std::copy(__x.begin(), __x.end(), begin());
> this->_M_impl._M_finish = begin() + difference_type(__x.size());
> return *this;
> }
>
>
>
>
>
>
> void
> _M_fill_assign(size_t __n, bool __x)
> {
> if (__n > size())
> {
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> insert(end(), __n - size(), __x);
> }
> else
> {
> erase(begin() + __n, end());
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
> }
>
> void
> assign(size_t __n, bool __x)
> { _M_fill_assign(__n, __x); }
>
> template<class _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
> template<class _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign((size_t) __n, (bool) __val); }
>
> template<class _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
>
> template<class _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur = begin();
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> erase(__cur, end());
> else
> insert(end(), __first, __last);
> }
>
> template<class _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len < size())
> erase(std::copy(__first, __last, begin()), end());
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> }
>
> void
> reserve(size_type __n)
> {
> if (__n > this->max_size())
> __throw_length_error(("vector::reserve"));
> if (this->capacity() < __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_finish = std::copy(begin(), end(),
> iterator(__q, 0));
> this->_M_deallocate();
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
> / int(_S_word_bit));
> }
> }
>
> reference
> front()
> { return *begin(); }
>
> const_reference
> front() const
> { return *begin(); }
>
> reference
> back()
> { return *(end() - 1); }
>
> const_reference
> back() const
> { return *(end() - 1); }
>
>
>
>
>
>
> void
> data() { }
>
> void
> push_back(bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(end(), __x);
> }
>
> void
> swap(vector<bool, _Alloc>& __x)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_end_of_storage,
> __x._M_impl._M_end_of_storage);
> }
>
>
> static void
> swap(reference __x, reference __y)
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> iterator
> insert(iterator __position, bool __x = bool())
> {
> const difference_type __n = __position - begin();
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
> && __position == end())
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(__position, __x);
> return begin() + __n;
> }
>
>
>
> template<class _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> { _M_fill_insert(__pos, __n, __x); }
>
> template<class _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_insert_range(__pos, __first, __last,
> std::__iterator_category(__first)); }
>
> template<class _InputIterator>
> void
> insert(iterator __position,
> _InputIterator __first, _InputIterator __last)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
>
> void
> _M_fill_insert(iterator __position, size_type __n, bool __x)
> {
> if (__n == 0)
> return;
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish + difference_type(__n));
> std::fill(__position, __position + difference_type(__n), __x);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len = size() + std::max(size(), __n);
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = std::copy(begin(), __position, iterator(__q, 0));
> std::fill_n(__i, __n, __x);
> this->_M_impl._M_finish = std::copy(__position, end(),
> __i + difference_type(__n));
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = (__q + ((__len
> + int(_S_word_bit) - 1)
> / int(_S_word_bit)));
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
> void
> insert(iterator __position, size_type __n, bool __x)
> { _M_fill_insert(__position, __n, __x); }
>
> void
> pop_back()
> { --this->_M_impl._M_finish; }
>
> iterator
> erase(iterator __position)
> {
> if (__position + 1 != end())
> std::copy(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> return __position;
> }
>
> iterator
> erase(iterator __first, iterator __last)
> {
> this->_M_impl._M_finish = std::copy(__last, end(), __first);
> return __first;
> }
>
> void
> resize(size_type __new_size, bool __x = bool())
> {
> if (__new_size < size())
> erase(begin() + difference_type(__new_size), end());
> else
> insert(end(), __new_size - size(), __x);
> }
>
> void
> flip()
> {
> for (_Bit_type * __p = this->_M_impl._M_start._M_p;
> __p != this->_M_impl._M_end_of_storage; ++__p)
> *__p = ~*__p;
> }
>
> void
> clear()
> { erase(begin(), end()); }
> };
>}
># 72 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/vector" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/vector.tcc" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/vector.tcc" 3
>namespace std
>{
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> reserve(size_type __n)
> {
> if (__n > this->max_size())
> __throw_length_error(("vector::reserve"));
> if (this->capacity() < __n)
> {
> const size_type __old_size = size();
> pointer __tmp = _M_allocate_and_copy(__n,
> this->_M_impl._M_start,
> this->_M_impl._M_finish);
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = __tmp + __old_size;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> const size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
> && __position == end())
> {
> this->_M_impl.construct(this->_M_impl._M_finish, __x);
> ++this->_M_impl._M_finish;
> }
> else
> _M_insert_aux(__position, __x);
> return begin() + __n;
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> erase(iterator __position)
> {
> if (__position + 1 != end())
> std::copy(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> this->_M_impl.destroy(this->_M_impl._M_finish);
> return __position;
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> iterator __i(std::copy(__last, end(), __first));
> std::_Destroy(__i, end(), _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_finish - (__last - __first);
> return __first;
> }
>
> template<typename _Tp, typename _Alloc>
> vector<_Tp, _Alloc>&
> vector<_Tp, _Alloc>::
> operator=(const vector<_Tp, _Alloc>& __x)
> {
> if (&__x != this)
> {
> const size_type __xlen = __x.size();
> if (__xlen > capacity())
> {
> pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
> __x.end());
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
> }
> else if (size() >= __xlen)
> {
> iterator __i(std::copy(__x.begin(), __x.end(), begin()));
> std::_Destroy(__i, end(), _M_get_Tp_allocator());
> }
> else
> {
> std::copy(__x.begin(), __x.begin() + size(),
> this->_M_impl._M_start);
> std::__uninitialized_copy_a(__x.begin() + size(),
> __x.end(), this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
> }
> return *this;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_assign(size_t __n, const value_type& __val)
> {
> if (__n > capacity())
> {
> vector __tmp(__n, __val, _M_get_Tp_allocator());
> __tmp.swap(*this);
> }
> else if (__n > size())
> {
> std::fill(begin(), end(), __val);
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - size(), __val,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - size();
> }
> else
> erase(std::fill_n(begin(), __n, __val), end());
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur(begin());
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> erase(__cur, end());
> else
> insert(end(), __first, __last);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
>
> if (__len > capacity())
> {
> pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = this->_M_impl._M_start + __len;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
> }
> else if (size() >= __len)
> {
> iterator __new_finish(std::copy(__first, __last,
> this->_M_impl._M_start));
> std::_Destroy(__new_finish, end(), _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish.base();
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, this->_M_impl._M_start);
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_insert_aux(iterator __position, const _Tp& __x)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> this->_M_impl.construct(this->_M_impl._M_finish,
> *(this->_M_impl._M_finish - 1));
> ++this->_M_impl._M_finish;
> _Tp __x_copy = __x;
> std::copy_backward(__position,
> iterator(this->_M_impl._M_finish-2),
> iterator(this->_M_impl._M_finish-1));
> *__position = __x_copy;
> }
> else
> {
> const size_type __old_size = size();
> if (__old_size == this->max_size())
> __throw_length_error(("vector::_M_insert_aux"));
>
>
>
>
> size_type __len = __old_size != 0 ? 2 * __old_size : 1;
> if (__len < __old_size)
> __len = this->max_size();
>
> iterator __new_start(this->_M_allocate(__len));
> iterator __new_finish(__new_start);
> try
> {
> __new_finish =
> std::__uninitialized_copy_a(iterator(this->_M_impl._M_start),
> __position,
> __new_start,
> _M_get_Tp_allocator());
> this->_M_impl.construct(__new_finish.base(), __x);
> ++__new_finish;
> __new_finish =
> std::__uninitialized_copy_a(__position,
> iterator(this->_M_impl._M_finish),
> __new_finish,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
> _M_deallocate(__new_start.base(),__len);
> throw;
> }
> std::_Destroy(begin(), end(), _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start.base();
> this->_M_impl._M_finish = __new_finish.base();
> this->_M_impl._M_end_of_storage = __new_start.base() + __len;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
> {
> if (__n != 0)
> {
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> value_type __x_copy = __x;
> const size_type __elems_after = end() - __position;
> iterator __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::__uninitialized_copy_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> std::copy_backward(__position, __old_finish - __n,
> __old_finish);
> std::fill(__position, __position + __n, __x_copy);
> }
> else
> {
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - __elems_after,
> __x_copy,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> std::__uninitialized_copy_a(__position, __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> std::fill(__position, __old_finish, __x_copy);
> }
> }
> else
> {
> const size_type __old_size = size();
> if (this->max_size() - __old_size < __n)
> __throw_length_error(("vector::_M_fill_insert"));
>
>
> size_type __len = __old_size + std::max(__old_size, __n);
> if (__len < __old_size)
> __len = this->max_size();
>
> iterator __new_start(this->_M_allocate(__len));
> iterator __new_finish(__new_start);
> try
> {
> __new_finish =
> std::__uninitialized_copy_a(begin(), __position,
> __new_start,
> _M_get_Tp_allocator());
> std::__uninitialized_fill_n_a(__new_finish, __n, __x,
> _M_get_Tp_allocator());
> __new_finish += __n;
> __new_finish =
> std::__uninitialized_copy_a(__position, end(), __new_finish,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start.base(), __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start.base();
> this->_M_impl._M_finish = __new_finish.base();
> this->_M_impl._M_end_of_storage = __new_start.base() + __len;
> }
> }
> }
>
> template<typename _Tp, typename _Alloc> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> const size_type __n = std::distance(__first, __last);
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> const size_type __elems_after = end() - __position;
> iterator __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::__uninitialized_copy_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> std::copy_backward(__position, __old_finish - __n,
> __old_finish);
> std::copy(__first, __last, __position);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elems_after);
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> std::__uninitialized_copy_a(__position, __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> std::copy(__first, __mid, __position);
> }
> }
> else
> {
> const size_type __old_size = size();
> if (this->max_size() - __old_size < __n)
> __throw_length_error(("vector::_M_range_insert"));
>
>
> size_type __len = __old_size + std::max(__old_size, __n);
> if (__len < __old_size)
> __len = this->max_size();
>
> iterator __new_start(this->_M_allocate(__len));
> iterator __new_finish(__new_start);
> try
> {
> __new_finish =
> std::__uninitialized_copy_a(iterator(this->_M_impl._M_start),
> __position,
> __new_start,
> _M_get_Tp_allocator());
> __new_finish =
> std::__uninitialized_copy_a(__first, __last, __new_finish,
> _M_get_Tp_allocator());
> __new_finish =
> std::__uninitialized_copy_a(__position,
> iterator(this->_M_impl._M_finish),
> __new_finish,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start,__new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start.base(), __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start.base();
> this->_M_impl._M_finish = __new_finish.base();
> this->_M_impl._M_end_of_storage = __new_start.base() + __len;
> }
> }
> }
>}
># 75 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/vector" 2 3
># 13 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/map" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/map" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/map" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_tree.h" 1 3
># 72 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_tree.h" 3
>namespace std
>{
># 90 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_tree.h" 3
> enum _Rb_tree_color { _S_red = false, _S_black = true };
>
> struct _Rb_tree_node_base
> {
> typedef _Rb_tree_node_base* _Base_ptr;
> typedef const _Rb_tree_node_base* _Const_Base_ptr;
>
> _Rb_tree_color _M_color;
> _Base_ptr _M_parent;
> _Base_ptr _M_left;
> _Base_ptr _M_right;
>
> static _Base_ptr
> _S_minimum(_Base_ptr __x)
> {
> while (__x->_M_left != 0) __x = __x->_M_left;
> return __x;
> }
>
> static _Const_Base_ptr
> _S_minimum(_Const_Base_ptr __x)
> {
> while (__x->_M_left != 0) __x = __x->_M_left;
> return __x;
> }
>
> static _Base_ptr
> _S_maximum(_Base_ptr __x)
> {
> while (__x->_M_right != 0) __x = __x->_M_right;
> return __x;
> }
>
> static _Const_Base_ptr
> _S_maximum(_Const_Base_ptr __x)
> {
> while (__x->_M_right != 0) __x = __x->_M_right;
> return __x;
> }
> };
>
> template<typename _Val>
> struct _Rb_tree_node : public _Rb_tree_node_base
> {
> typedef _Rb_tree_node<_Val>* _Link_type;
> _Val _M_value_field;
> };
>
> _Rb_tree_node_base*
> _Rb_tree_increment(_Rb_tree_node_base* __x);
>
> const _Rb_tree_node_base*
> _Rb_tree_increment(const _Rb_tree_node_base* __x);
>
> _Rb_tree_node_base*
> _Rb_tree_decrement(_Rb_tree_node_base* __x);
>
> const _Rb_tree_node_base*
> _Rb_tree_decrement(const _Rb_tree_node_base* __x);
>
> template<typename _Tp>
> struct _Rb_tree_iterator
> {
> typedef _Tp value_type;
> typedef _Tp& reference;
> typedef _Tp* pointer;
>
> typedef bidirectional_iterator_tag iterator_category;
> typedef ptrdiff_t difference_type;
>
> typedef _Rb_tree_iterator<_Tp> _Self;
> typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
> typedef _Rb_tree_node<_Tp>* _Link_type;
>
> _Rb_tree_iterator()
> : _M_node() { }
>
> explicit
> _Rb_tree_iterator(_Link_type __x)
> : _M_node(__x) { }
>
> reference
> operator*() const
> { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> pointer
> operator->() const
> { return &static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> _Self&
> operator++()
> {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
> _Base_ptr _M_node;
> };
>
> template<typename _Tp>
> struct _Rb_tree_const_iterator
> {
> typedef _Tp value_type;
> typedef const _Tp& reference;
> typedef const _Tp* pointer;
>
> typedef _Rb_tree_iterator<_Tp> iterator;
>
> typedef bidirectional_iterator_tag iterator_category;
> typedef ptrdiff_t difference_type;
>
> typedef _Rb_tree_const_iterator<_Tp> _Self;
> typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
> typedef const _Rb_tree_node<_Tp>* _Link_type;
>
> _Rb_tree_const_iterator()
> : _M_node() { }
>
> explicit
> _Rb_tree_const_iterator(_Link_type __x)
> : _M_node(__x) { }
>
> _Rb_tree_const_iterator(const iterator& __it)
> : _M_node(__it._M_node) { }
>
> reference
> operator*() const
> { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> pointer
> operator->() const
> { return &static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> _Self&
> operator++()
> {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
> _Base_ptr _M_node;
> };
>
> template<typename _Val>
> inline bool
> operator==(const _Rb_tree_iterator<_Val>& __x,
> const _Rb_tree_const_iterator<_Val>& __y)
> { return __x._M_node == __y._M_node; }
>
> template<typename _Val>
> inline bool
> operator!=(const _Rb_tree_iterator<_Val>& __x,
> const _Rb_tree_const_iterator<_Val>& __y)
> { return __x._M_node != __y._M_node; }
>
> void
> _Rb_tree_rotate_left(_Rb_tree_node_base* const __x,
> _Rb_tree_node_base*& __root);
>
> void
> _Rb_tree_rotate_right(_Rb_tree_node_base* const __x,
> _Rb_tree_node_base*& __root);
>
> void
> _Rb_tree_insert_and_rebalance(const bool __insert_left,
> _Rb_tree_node_base* __x,
> _Rb_tree_node_base* __p,
> _Rb_tree_node_base& __header);
>
> _Rb_tree_node_base*
> _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
> _Rb_tree_node_base& __header);
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc = allocator<_Val> >
> class _Rb_tree
> {
> typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
> _Node_allocator;
>
> protected:
> typedef _Rb_tree_node_base* _Base_ptr;
> typedef const _Rb_tree_node_base* _Const_Base_ptr;
> typedef _Rb_tree_node<_Val> _Rb_tree_node;
>
> public:
> typedef _Key key_type;
> typedef _Val value_type;
> typedef value_type* pointer;
> typedef const value_type* const_pointer;
> typedef value_type& reference;
> typedef const value_type& const_reference;
> typedef _Rb_tree_node* _Link_type;
> typedef const _Rb_tree_node* _Const_Link_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
>
> protected:
> _Rb_tree_node*
> _M_get_node()
> { return _M_impl._Node_allocator::allocate(1); }
>
> void
> _M_put_node(_Rb_tree_node* __p)
> { _M_impl._Node_allocator::deallocate(__p, 1); }
>
> _Link_type
> _M_create_node(const value_type& __x)
> {
> _Link_type __tmp = _M_get_node();
> try
> { get_allocator().construct(&__tmp->_M_value_field, __x); }
> catch(...)
> {
> _M_put_node(__tmp);
> throw;
> }
> return __tmp;
> }
>
> _Link_type
> _M_clone_node(_Const_Link_type __x)
> {
> _Link_type __tmp = _M_create_node(__x->_M_value_field);
> __tmp->_M_color = __x->_M_color;
> __tmp->_M_left = 0;
> __tmp->_M_right = 0;
> return __tmp;
> }
>
> void
> destroy_node(_Link_type __p)
> {
> get_allocator().destroy(&__p->_M_value_field);
> _M_put_node(__p);
> }
>
> protected:
> template<typename _Key_compare,
> bool _Is_pod_comparator = std::__is_pod<_Key_compare>::__value>
> struct _Rb_tree_impl : public _Node_allocator
> {
> _Key_compare _M_key_compare;
> _Rb_tree_node_base _M_header;
> size_type _M_node_count;
>
> _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
> const _Key_compare& __comp = _Key_compare())
> : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
> _M_node_count(0)
> {
> this->_M_header._M_color = _S_red;
> this->_M_header._M_parent = 0;
> this->_M_header._M_left = &this->_M_header;
> this->_M_header._M_right = &this->_M_header;
> }
> };
>
>
>
> template<typename _Key_compare>
> struct _Rb_tree_impl<_Key_compare, true> : public _Node_allocator
> {
> _Key_compare _M_key_compare;
> _Rb_tree_node_base _M_header;
> size_type _M_node_count;
>
> _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
> const _Key_compare& __comp = _Key_compare())
> : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
> _M_node_count(0)
> {
> this->_M_header._M_color = _S_red;
> this->_M_header._M_parent = 0;
> this->_M_header._M_left = &this->_M_header;
> this->_M_header._M_right = &this->_M_header;
> }
> };
>
> _Rb_tree_impl<_Compare> _M_impl;
>
> protected:
> _Base_ptr&
> _M_root()
> { return this->_M_impl._M_header._M_parent; }
>
> _Const_Base_ptr
> _M_root() const
> { return this->_M_impl._M_header._M_parent; }
>
> _Base_ptr&
> _M_leftmost()
> { return this->_M_impl._M_header._M_left; }
>
> _Const_Base_ptr
> _M_leftmost() const
> { return this->_M_impl._M_header._M_left; }
>
> _Base_ptr&
> _M_rightmost()
> { return this->_M_impl._M_header._M_right; }
>
> _Const_Base_ptr
> _M_rightmost() const
> { return this->_M_impl._M_header._M_right; }
>
> _Link_type
> _M_begin()
> { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
>
> _Const_Link_type
> _M_begin() const
> {
> return static_cast<_Const_Link_type>
> (this->_M_impl._M_header._M_parent);
> }
>
> _Link_type
> _M_end()
> { return static_cast<_Link_type>(&this->_M_impl._M_header); }
>
> _Const_Link_type
> _M_end() const
> { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
>
> static const_reference
> _S_value(_Const_Link_type __x)
> { return __x->_M_value_field; }
>
> static const _Key&
> _S_key(_Const_Link_type __x)
> { return _KeyOfValue()(_S_value(__x)); }
>
> static _Link_type
> _S_left(_Base_ptr __x)
> { return static_cast<_Link_type>(__x->_M_left); }
>
> static _Const_Link_type
> _S_left(_Const_Base_ptr __x)
> { return static_cast<_Const_Link_type>(__x->_M_left); }
>
> static _Link_type
> _S_right(_Base_ptr __x)
> { return static_cast<_Link_type>(__x->_M_right); }
>
> static _Const_Link_type
> _S_right(_Const_Base_ptr __x)
> { return static_cast<_Const_Link_type>(__x->_M_right); }
>
> static const_reference
> _S_value(_Const_Base_ptr __x)
> { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
>
> static const _Key&
> _S_key(_Const_Base_ptr __x)
> { return _KeyOfValue()(_S_value(__x)); }
>
> static _Base_ptr
> _S_minimum(_Base_ptr __x)
> { return _Rb_tree_node_base::_S_minimum(__x); }
>
> static _Const_Base_ptr
> _S_minimum(_Const_Base_ptr __x)
> { return _Rb_tree_node_base::_S_minimum(__x); }
>
> static _Base_ptr
> _S_maximum(_Base_ptr __x)
> { return _Rb_tree_node_base::_S_maximum(__x); }
>
> static _Const_Base_ptr
> _S_maximum(_Const_Base_ptr __x)
> { return _Rb_tree_node_base::_S_maximum(__x); }
>
> public:
> typedef _Rb_tree_iterator<value_type> iterator;
> typedef _Rb_tree_const_iterator<value_type> const_iterator;
>
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>
> private:
> iterator
> _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
>
> const_iterator
> _M_insert(_Const_Base_ptr __x, _Const_Base_ptr __y,
> const value_type& __v);
>
> _Link_type
> _M_copy(_Const_Link_type __x, _Link_type __p);
>
> void
> _M_erase(_Link_type __x);
>
> public:
>
> _Rb_tree()
> { }
>
> _Rb_tree(const _Compare& __comp)
> : _M_impl(allocator_type(), __comp)
> { }
>
> _Rb_tree(const _Compare& __comp, const allocator_type& __a)
> : _M_impl(__a, __comp)
> { }
>
> _Rb_tree(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
> : _M_impl(__x.get_allocator(), __x._M_impl._M_key_compare)
> {
> if (__x._M_root() != 0)
> {
> _M_root() = _M_copy(__x._M_begin(), _M_end());
> _M_leftmost() = _S_minimum(_M_root());
> _M_rightmost() = _S_maximum(_M_root());
> _M_impl._M_node_count = __x._M_impl._M_node_count;
> }
> }
>
> ~_Rb_tree()
> { _M_erase(_M_begin()); }
>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
> operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x);
>
>
> _Compare
> key_comp() const
> { return _M_impl._M_key_compare; }
>
> iterator
> begin()
> {
> return iterator(static_cast<_Link_type>
> (this->_M_impl._M_header._M_left));
> }
>
> const_iterator
> begin() const
> {
> return const_iterator(static_cast<_Const_Link_type>
> (this->_M_impl._M_header._M_left));
> }
>
> iterator
> end()
> { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
>
> const_iterator
> end() const
> {
> return const_iterator(static_cast<_Const_Link_type>
> (&this->_M_impl._M_header));
> }
>
> reverse_iterator
> rbegin()
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend()
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const
> { return const_reverse_iterator(begin()); }
>
> bool
> empty() const
> { return _M_impl._M_node_count == 0; }
>
> size_type
> size() const
> { return _M_impl._M_node_count; }
>
> size_type
> max_size() const
> { return size_type(-1); }
>
> void
> swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t);
>
>
> pair<iterator,bool>
> insert_unique(const value_type& __x);
>
> iterator
> insert_equal(const value_type& __x);
>
> iterator
> insert_unique(iterator __position, const value_type& __x);
>
> const_iterator
> insert_unique(const_iterator __position, const value_type& __x);
>
> iterator
> insert_equal(iterator __position, const value_type& __x);
>
> const_iterator
> insert_equal(const_iterator __position, const value_type& __x);
>
> template<typename _InputIterator>
> void
> insert_unique(_InputIterator __first, _InputIterator __last);
>
> template<typename _InputIterator>
> void
> insert_equal(_InputIterator __first, _InputIterator __last);
>
> void
> erase(iterator __position);
>
> void
> erase(const_iterator __position);
>
> size_type
> erase(const key_type& __x);
>
> void
> erase(iterator __first, iterator __last);
>
> void
> erase(const_iterator __first, const_iterator __last);
>
> void
> erase(const key_type* __first, const key_type* __last);
>
> void
> clear()
> {
> _M_erase(_M_begin());
> _M_leftmost() = _M_end();
> _M_root() = 0;
> _M_rightmost() = _M_end();
> _M_impl._M_node_count = 0;
> }
>
>
> iterator
> find(const key_type& __x);
>
> const_iterator
> find(const key_type& __x) const;
>
> size_type
> count(const key_type& __x) const;
>
> iterator
> lower_bound(const key_type& __x);
>
> const_iterator
> lower_bound(const key_type& __x) const;
>
> iterator
> upper_bound(const key_type& __x);
>
> const_iterator
> upper_bound(const key_type& __x) const;
>
> pair<iterator,iterator>
> equal_range(const key_type& __x);
>
> pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const;
>
>
> bool
> __rb_verify() const;
> };
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> {
> return __x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> {
> return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
> {
> if (this != &__x)
> {
>
> clear();
> _M_impl._M_key_compare = __x._M_impl._M_key_compare;
> if (__x._M_root() != 0)
> {
> _M_root() = _M_copy(__x._M_begin(), _M_end());
> _M_leftmost() = _S_minimum(_M_root());
> _M_rightmost() = _S_maximum(_M_root());
> _M_impl._M_node_count = __x._M_impl._M_node_count;
> }
> }
> return *this;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
> {
> bool __insert_left = (__x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__p)));
>
> _Link_type __z = _M_create_node(__v);
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
> {
> bool __insert_left = (__x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__p)));
>
> _Link_type __z = _M_create_node(__v);
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z,
> const_cast<_Base_ptr>(__p),
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return const_iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> insert_equal(const _Val& __v)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _M_insert(__x, __y, __v);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
> {
> if (_M_root() == 0)
> {
> if (__t._M_root() != 0)
> {
> _M_root() = __t._M_root();
> _M_leftmost() = __t._M_leftmost();
> _M_rightmost() = __t._M_rightmost();
> _M_root()->_M_parent = _M_end();
>
> __t._M_root() = 0;
> __t._M_leftmost() = __t._M_end();
> __t._M_rightmost() = __t._M_end();
> }
> }
> else if (__t._M_root() == 0)
> {
> __t._M_root() = _M_root();
> __t._M_leftmost() = _M_leftmost();
> __t._M_rightmost() = _M_rightmost();
> __t._M_root()->_M_parent = __t._M_end();
>
> _M_root() = 0;
> _M_leftmost() = _M_end();
> _M_rightmost() = _M_end();
> }
> else
> {
> std::swap(_M_root(),__t._M_root());
> std::swap(_M_leftmost(),__t._M_leftmost());
> std::swap(_M_rightmost(),__t._M_rightmost());
>
> _M_root()->_M_parent = _M_end();
> __t._M_root()->_M_parent = __t._M_end();
> }
>
> std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
> std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator, bool>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> insert_unique(const _Val& __v)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> bool __comp = true;
> while (__x != 0)
> {
> __y = __x;
> __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
> __x = __comp ? _S_left(__x) : _S_right(__x);
> }
> iterator __j = iterator(__y);
> if (__comp)
> if (__j == begin())
> return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
> else
> --__j;
> if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
> return pair<iterator, bool>(_M_insert(__x, __y, __v), true);
> return pair<iterator, bool>(__j, false);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> insert_unique(iterator __position, const _Val& __v)
> {
>
> if (__position._M_node == _M_end())
> {
> if (size() > 0
> && _M_impl._M_key_compare(_S_key(_M_rightmost()),
> _KeyOfValue()(__v)))
> return _M_insert(0, _M_rightmost(), __v);
> else
> return insert_unique(__v).first;
> }
> else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__position._M_node)))
> {
>
> iterator __before = __position;
> if (__position._M_node == _M_leftmost())
> return _M_insert(_M_leftmost(), _M_leftmost(), __v);
> else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
> _KeyOfValue()(__v)))
> {
> if (_S_right(__before._M_node) == 0)
> return _M_insert(0, __before._M_node, __v);
> else
> return _M_insert(__position._M_node,
> __position._M_node, __v);
> }
> else
> return insert_unique(__v).first;
> }
> else if (_M_impl._M_key_compare(_S_key(__position._M_node),
> _KeyOfValue()(__v)))
> {
>
> iterator __after = __position;
> if (__position._M_node == _M_rightmost())
> return _M_insert(0, _M_rightmost(), __v);
> else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key((++__after)._M_node)))
> {
> if (_S_right(__position._M_node) == 0)
> return _M_insert(0, __position._M_node, __v);
> else
> return _M_insert(__after._M_node, __after._M_node, __v);
> }
> else
> return insert_unique(__v).first;
> }
> else
> return __position;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> insert_unique(const_iterator __position, const _Val& __v)
> {
>
> if (__position._M_node == _M_end())
> {
> if (size() > 0
> && _M_impl._M_key_compare(_S_key(_M_rightmost()),
> _KeyOfValue()(__v)))
> return _M_insert(0, _M_rightmost(), __v);
> else
> return const_iterator(insert_unique(__v).first);
> }
> else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__position._M_node)))
> {
>
> const_iterator __before = __position;
> if (__position._M_node == _M_leftmost())
> return _M_insert(_M_leftmost(), _M_leftmost(), __v);
> else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
> _KeyOfValue()(__v)))
> {
> if (_S_right(__before._M_node) == 0)
> return _M_insert(0, __before._M_node, __v);
> else
> return _M_insert(__position._M_node,
> __position._M_node, __v);
> }
> else
> return const_iterator(insert_unique(__v).first);
> }
> else if (_M_impl._M_key_compare(_S_key(__position._M_node),
> _KeyOfValue()(__v)))
> {
>
> const_iterator __after = __position;
> if (__position._M_node == _M_rightmost())
> return _M_insert(0, _M_rightmost(), __v);
> else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key((++__after)._M_node)))
> {
> if (_S_right(__position._M_node) == 0)
> return _M_insert(0, __position._M_node, __v);
> else
> return _M_insert(__after._M_node, __after._M_node, __v);
> }
> else
> return const_iterator(insert_unique(__v).first);
> }
> else
> return __position;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> insert_equal(iterator __position, const _Val& __v)
> {
>
> if (__position._M_node == _M_end())
> {
> if (size() > 0
> && !_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(_M_rightmost())))
> return _M_insert(0, _M_rightmost(), __v);
> else
> return insert_equal(__v);
> }
> else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
> _KeyOfValue()(__v)))
> {
>
> iterator __before = __position;
> if (__position._M_node == _M_leftmost())
> return _M_insert(_M_leftmost(), _M_leftmost(), __v);
> else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key((--__before)._M_node)))
> {
> if (_S_right(__before._M_node) == 0)
> return _M_insert(0, __before._M_node, __v);
> else
> return _M_insert(__position._M_node,
> __position._M_node, __v);
> }
> else
> return insert_equal(__v);
> }
> else
> {
>
> iterator __after = __position;
> if (__position._M_node == _M_rightmost())
> return _M_insert(0, _M_rightmost(), __v);
> else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
> _KeyOfValue()(__v)))
> {
> if (_S_right(__position._M_node) == 0)
> return _M_insert(0, __position._M_node, __v);
> else
> return _M_insert(__after._M_node, __after._M_node, __v);
> }
> else
> return insert_equal(__v);
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> insert_equal(const_iterator __position, const _Val& __v)
> {
>
> if (__position._M_node == _M_end())
> {
> if (size() > 0
> && !_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(_M_rightmost())))
> return _M_insert(0, _M_rightmost(), __v);
> else
> return const_iterator(insert_equal(__v));
> }
> else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
> _KeyOfValue()(__v)))
> {
>
> const_iterator __before = __position;
> if (__position._M_node == _M_leftmost())
> return _M_insert(_M_leftmost(), _M_leftmost(), __v);
> else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key((--__before)._M_node)))
> {
> if (_S_right(__before._M_node) == 0)
> return _M_insert(0, __before._M_node, __v);
> else
> return _M_insert(__position._M_node,
> __position._M_node, __v);
> }
> else
> return const_iterator(insert_equal(__v));
> }
> else
> {
>
> const_iterator __after = __position;
> if (__position._M_node == _M_rightmost())
> return _M_insert(0, _M_rightmost(), __v);
> else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
> _KeyOfValue()(__v)))
> {
> if (_S_right(__position._M_node) == 0)
> return _M_insert(0, __position._M_node, __v);
> else
> return _M_insert(__after._M_node, __after._M_node, __v);
> }
> else
> return const_iterator(insert_equal(__v));
> }
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
> insert_equal(_II __first, _II __last)
> {
> for (; __first != __last; ++__first)
> insert_equal(end(), *__first);
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
> insert_unique(_II __first, _II __last)
> {
> for (; __first != __last; ++__first)
> insert_unique(end(), *__first);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(iterator __position)
> {
> _Link_type __y =
> static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
> (__position._M_node,
> this->_M_impl._M_header));
> destroy_node(__y);
> --_M_impl._M_node_count;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const_iterator __position)
> {
> _Link_type __y =
> static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
> (const_cast<_Base_ptr>(__position._M_node),
> this->_M_impl._M_header));
> destroy_node(__y);
> --_M_impl._M_node_count;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const _Key& __x)
> {
> pair<iterator,iterator> __p = equal_range(__x);
> size_type __n = std::distance(__p.first, __p.second);
> erase(__p.first, __p.second);
> return __n;
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
> _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
> _M_copy(_Const_Link_type __x, _Link_type __p)
> {
>
> _Link_type __top = _M_clone_node(__x);
> __top->_M_parent = __p;
>
> try
> {
> if (__x->_M_right)
> __top->_M_right = _M_copy(_S_right(__x), __top);
> __p = __top;
> __x = _S_left(__x);
>
> while (__x != 0)
> {
> _Link_type __y = _M_clone_node(__x);
> __p->_M_left = __y;
> __y->_M_parent = __p;
> if (__x->_M_right)
> __y->_M_right = _M_copy(_S_right(__x), __y);
> __p = __y;
> __x = _S_left(__x);
> }
> }
> catch(...)
> {
> _M_erase(__top);
> throw;
> }
> return __top;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase(_Link_type __x)
> {
>
> while (__x != 0)
> {
> _M_erase(_S_right(__x));
> _Link_type __y = _S_left(__x);
> destroy_node(__x);
> __x = __y;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> if (__first == begin() && __last == end())
> clear();
> else
> while (__first != __last)
> erase(__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const_iterator __first, const_iterator __last)
> {
> if (__first == begin() && __last == end())
> clear();
> else
> while (__first != __last)
> erase(__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const _Key* __first, const _Key* __last)
> {
> while (__first != __last)
> erase(*__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> find(const _Key& __k)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
>
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
>
> iterator __j = iterator(__y);
> return (__j == end()
> || _M_impl._M_key_compare(__k,
> _S_key(__j._M_node))) ? end() : __j;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> find(const _Key& __k) const
> {
> _Const_Link_type __x = _M_begin();
> _Const_Link_type __y = _M_end();
>
> while (__x != 0)
> {
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> }
> const_iterator __j = const_iterator(__y);
> return (__j == end()
> || _M_impl._M_key_compare(__k,
> _S_key(__j._M_node))) ? end() : __j;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> count(const _Key& __k) const
> {
> pair<const_iterator, const_iterator> __p = equal_range(__k);
> const size_type __n = std::distance(__p.first, __p.second);
> return __n;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> lower_bound(const _Key& __k)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
>
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
>
> return iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> lower_bound(const _Key& __k) const
> {
> _Const_Link_type __x = _M_begin();
> _Const_Link_type __y = _M_end();
>
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
>
> return const_iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> upper_bound(const _Key& __k)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
>
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
>
> return iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> upper_bound(const _Key& __k) const
> {
> _Const_Link_type __x = _M_begin();
> _Const_Link_type __y = _M_end();
>
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
>
> return const_iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator,
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> equal_range(const _Key& __k)
> { return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k)); }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Compare, typename _Alloc>
> inline
> pair<typename _Rb_tree<_Key, _Val, _KoV,
> _Compare, _Alloc>::const_iterator,
> typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator>
> _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
> equal_range(const _Key& __k) const
> { return pair<const_iterator, const_iterator>(lower_bound(__k),
> upper_bound(__k)); }
>
> unsigned int
> _Rb_tree_black_count(const _Rb_tree_node_base* __node,
> const _Rb_tree_node_base* __root);
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> bool
> _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
> {
> if (_M_impl._M_node_count == 0 || begin() == end())
> return _M_impl._M_node_count == 0 && begin() == end()
> && this->_M_impl._M_header._M_left == _M_end()
> && this->_M_impl._M_header._M_right == _M_end();
>
> unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
> for (const_iterator __it = begin(); __it != end(); ++__it)
> {
> _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
> _Const_Link_type __L = _S_left(__x);
> _Const_Link_type __R = _S_right(__x);
>
> if (__x->_M_color == _S_red)
> if ((__L && __L->_M_color == _S_red)
> || (__R && __R->_M_color == _S_red))
> return false;
>
> if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
> return false;
> if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
> return false;
>
> if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
> return false;
> }
>
> if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
> return false;
> if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
> return false;
> return true;
> }
>}
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/map" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
>namespace std
>{
># 90 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
> typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
> class map
> {
> public:
> typedef _Key key_type;
> typedef _Tp mapped_type;
> typedef std::pair<const _Key, _Tp> value_type;
> typedef _Compare key_compare;
> typedef _Alloc allocator_type;
>
> private:
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
> class value_compare
> : public std::binary_function<value_type, value_type, bool>
> {
> friend class map<_Key, _Tp, _Compare, _Alloc>;
> protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
> public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
> };
>
> private:
>
> typedef typename _Alloc::template rebind<value_type>::other
> _Pair_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
> key_compare, _Pair_alloc_type> _Rep_type;
>
>
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Pair_alloc_type::pointer pointer;
> typedef typename _Pair_alloc_type::const_pointer const_pointer;
> typedef typename _Pair_alloc_type::reference reference;
> typedef typename _Pair_alloc_type::const_reference const_reference;
> typedef typename _Rep_type::iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
> typedef typename _Rep_type::reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
>
>
>
>
>
> map()
> : _M_t(_Compare(), allocator_type()) { }
>
>
>
>
>
> explicit
> map(const _Compare& __comp, const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) { }
># 174 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> map(const map& __x)
> : _M_t(__x._M_t) { }
># 186 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> template <typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_unique(__first, __last); }
># 202 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> template <typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp, const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a)
> { _M_t.insert_unique(__first, __last); }
># 224 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> map&
> operator=(const map& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
> allocator_type
> get_allocator() const
> { return _M_t.get_allocator(); }
>
>
>
>
>
>
>
> iterator
> begin()
> { return _M_t.begin(); }
>
>
>
>
>
>
> const_iterator
> begin() const
> { return _M_t.begin(); }
>
>
>
>
>
> iterator
> end()
> { return _M_t.end(); }
>
>
>
>
>
>
> const_iterator
> end() const
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin()
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend()
> { return _M_t.rend(); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const
> { return _M_t.rend(); }
>
>
>
>
>
> bool
> empty() const
> { return _M_t.empty(); }
>
>
> size_type
> size() const
> { return _M_t.size(); }
>
>
> size_type
> max_size() const
> { return _M_t.max_size(); }
># 339 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> mapped_type&
> operator[](const key_type& __k)
> {
>
>
>
> iterator __i = lower_bound(__k);
>
> if (__i == end() || key_comp()(__k, (*__i).first))
> __i = insert(__i, value_type(__k, mapped_type()));
> return (*__i).second;
> }
># 361 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> mapped_type&
> at(const key_type& __k)
> {
> iterator __i = lower_bound(__k);
> if (__i == end() || key_comp()(__k, (*__i).first))
> __throw_out_of_range(("map::at"));
> return (*__i).second;
> }
>
> const mapped_type&
> at(const key_type& __k) const
> {
> const_iterator __i = lower_bound(__k);
> if (__i == end() || key_comp()(__k, (*__i).first))
> __throw_out_of_range(("map::at"));
> return (*__i).second;
> }
># 394 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> std::pair<iterator,bool>
> insert(const value_type& __x)
> { return _M_t.insert_unique(__x); }
># 418 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> iterator
> insert(iterator position, const value_type& __x)
> { return _M_t.insert_unique(position, __x); }
># 430 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> template <typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_unique(__first, __last); }
># 444 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> void
> erase(iterator __position)
> { _M_t.erase(__position); }
># 459 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 474 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> void
> erase(iterator __first, iterator __last)
> { _M_t.erase(__first, __last); }
># 489 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> void
> swap(map& __x)
> { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
> void
> clear()
> { _M_t.clear(); }
>
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
>
>
>
>
> value_compare
> value_comp() const
> { return value_compare(_M_t.key_comp()); }
># 532 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
># 547 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 559 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 574 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
># 589 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
>
>
>
>
>
>
>
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
>
>
>
>
>
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 628 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
># 647 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
> template <typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator== (const map<_K1, _T1, _C1, _A1>&,
> const map<_K1, _T1, _C1, _A1>&);
>
> template <typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator< (const map<_K1, _T1, _C1, _A1>&,
> const map<_K1, _T1, _C1, _A1>&);
> };
># 672 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 689 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_map.h" 3
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline void
> swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
> map<_Key, _Tp, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/map" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
>namespace std
>{
>
>
> template <typename _Key, typename _Tp,
> typename _Compare = std::less<_Key>,
> typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
> class multimap;
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y);
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y);
># 106 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> class multimap
> {
> public:
> typedef _Key key_type;
> typedef _Tp mapped_type;
> typedef std::pair<const _Key, _Tp> value_type;
> typedef _Compare key_compare;
> typedef _Alloc allocator_type;
>
> private:
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
> class value_compare
> : public std::binary_function<value_type, value_type, bool>
> {
> friend class multimap<_Key, _Tp, _Compare, _Alloc>;
> protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
> public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
> };
>
> private:
>
> typedef typename _Alloc::template rebind<value_type>::other
> _Pair_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
> key_compare, _Pair_alloc_type> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Pair_alloc_type::pointer pointer;
> typedef typename _Pair_alloc_type::const_pointer const_pointer;
> typedef typename _Pair_alloc_type::reference reference;
> typedef typename _Pair_alloc_type::const_reference const_reference;
> typedef typename _Rep_type::iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
> typedef typename _Rep_type::reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
>
>
>
>
> multimap()
> : _M_t(_Compare(), allocator_type()) { }
>
>
>
>
>
> explicit
> multimap(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) { }
># 188 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> multimap(const multimap& __x)
> : _M_t(__x._M_t) { }
># 200 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> template <typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_equal(__first, __last); }
># 216 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> template <typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a)
> { _M_t.insert_equal(__first, __last); }
># 239 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> multimap&
> operator=(const multimap& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
> allocator_type
> get_allocator() const
> { return _M_t.get_allocator(); }
>
>
>
>
>
>
>
> iterator
> begin()
> { return _M_t.begin(); }
>
>
>
>
>
>
> const_iterator
> begin() const
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> end()
> { return _M_t.end(); }
>
>
>
>
>
>
> const_iterator
> end() const
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin()
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend()
> { return _M_t.rend(); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const
> { return _M_t.rend(); }
>
>
>
> bool
> empty() const
> { return _M_t.empty(); }
>
>
> size_type
> size() const
> { return _M_t.size(); }
>
>
> size_type
> max_size() const
> { return _M_t.max_size(); }
># 353 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> iterator
> insert(const value_type& __x)
> { return _M_t.insert_equal(__x); }
># 377 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> iterator
> insert(iterator __position, const value_type& __x)
> { return _M_t.insert_equal(__position, __x); }
># 389 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> template <typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_equal(__first, __last); }
># 404 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> void
> erase(iterator __position)
> { _M_t.erase(__position); }
># 419 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 434 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> void
> erase(iterator __first, iterator __last)
> { _M_t.erase(__first, __last); }
># 449 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> void
> swap(multimap& __x)
> { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
> void
> clear()
> { _M_t.clear(); }
>
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
>
>
>
>
> value_compare
> value_comp() const
> { return value_compare(_M_t.key_comp()); }
># 492 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
># 507 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
>
>
>
>
>
>
> size_type
> count(const key_type& __x) const
> { return _M_t.count(__x); }
># 531 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
># 546 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
>
>
>
>
>
>
>
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
>
>
>
>
>
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 583 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
># 600 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
> template <typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator== (const multimap<_K1, _T1, _C1, _A1>&,
> const multimap<_K1, _T1, _C1, _A1>&);
>
> template <typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator< (const multimap<_K1, _T1, _C1, _A1>&,
> const multimap<_K1, _T1, _C1, _A1>&);
> };
># 625 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 642 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multimap.h" 3
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline void
> swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/map" 2 3
># 14 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrXmlDom.h" 2
>
>
>namespace FMR {
>
> namespace Streaming {
>
> enum XmlTag
> {
> XmlError = 0,
> XmlStartTag = 1,
> XmlEndTag = 2,
> XmlEmptyTag = 3,
> XmlText = 4,
> XmlCommentTag = 5,
> XmlDeclarTag = 6
> };
>
> namespace DomSpecs {
>
> class XmlNode
> {
> public:
> XmlNode();
> virtual ~XmlNode();
> bool is_read;
> std::string name;
> std::string value;
> private:
> typedef FMR::Platform::OnOffLocker<> LockModel;
> LockModel mx_node;
> };
>
> typedef std::stack<XmlNode*> XmlStack;
> typedef std::vector<DomSpecs::XmlNode*> XmlNodeList;
> typedef std::map<XmlNode*,XmlNodeList*> XmlTree;
>
> class XmlDomImpl
> {
> public:
> XmlDomImpl();
> virtual ~XmlDomImpl();
>
> XmlStack node_stack;
> XmlTree xml_tree;
> private:
> typedef FMR::Platform::OnOffLocker<> LockModel;
> LockModel mx_impl;
> };
>
> }
>
> class XmlDom
> {
> public:
>
>
>
> XmlDom(void);
>
> virtual ~XmlDom(void);
>
>
>
>
>
> virtual bool init(std::istream& in);
>
> virtual void drop(void);
>
> virtual bool enter(const std::string& name);
>
> virtual void leave(void);
>
> virtual bool next_name(std::string &) const;
>
> virtual bool head_name(std::string &) const;
>
> virtual bool test(const std::string& name) const;
>
> virtual bool get_last_err(std::string &) const;
>
>
> template <typename T>
> bool read(const std::string& label,T& value)
> {
> FMR::Platform::Lock<LockModel> lock(mx_dom);
> if(!enter(label)) return false;
> std::stringstream mystream(impl->node_stack.top()->value);
> mystream >> value;
> leave();
> return true;
> }
> bool read(const std::string& label,std::string& value)
> {
> FMR::Platform::Lock<LockModel> lock(mx_dom);
> if(!enter(label)) return false;
> value=impl->node_stack.top()->value;
> leave();
> return true;
> }
>
> private:
> DomSpecs::XmlNode* root;
> DomSpecs::XmlDomImpl* impl;
> std::string errmsg;
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_dom;
>
> virtual bool get_value(const std::string& label,char& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,unsigned char& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,short& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,unsigned short& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,int& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,unsigned int& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,long& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,unsigned long& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,float& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,double& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,bool& value) {return read(label,value);}
> virtual bool get_value(const std::string& label,std::string& value) {return read(label,value);}
> bool parse_name(std::string& name,short& id,std::istream& in);
> void parse_quotes(std::string& name);
> };
>
> }
>
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrBrowser.h" 2
># 13 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrBrowser.h"
>namespace FMR {
>
> namespace Streaming {
>
> namespace BrowserSpecs {
>
> class TypeManager
> {
> public:
> TypeManager() {}
> virtual ~TypeManager() {}
>
> virtual void* new_product(const std::string& type) =0;
> virtual void delete_product(void* product) =0;
> };
>
> }
>
> class Browser
> {
> public:
>
>
>
> template <typename TypeFactory>
> Browser(const TypeFactory& type_factory,std::istream& stream)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> factory = static_cast<BrowserSpecs::TypeManager*>(new TypeFactory());
> dom = new XmlDom();
> dom->init(stream);
> def = false;
> }
>
> virtual ~Browser()
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> if (dom) delete dom;
> dom = __null;
> if (factory) delete factory;
> factory = __null;
> }
>
>
>
>
>
> bool enter(const std::string& name)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> return dom->enter(name);
> }
>
> void leave(void)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> dom->leave();
> }
>
> bool next_name(std::string &next) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> return dom->next_name(next);
> }
>
> bool head_name(std::string &head) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> return dom->head_name(head);
> }
>
> bool test(const std::string& name) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> return dom->test(name);
> }
>
> bool get_last_err(std::string &err) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> return dom->get_last_err(err);
> }
>
> bool has_default()
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> return def;
> }
>
>
>
>
>
> template <typename T>
> err_t read(const std::string& name,T& value)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> bool found = dom->read(name,value);
> if (found) return 0;
> return 0x0a00;
> }
>
>
> template <typename T>
> err_t read(const std::string& name,T& value,T& default_value)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> if (dom->read(name,value)) return 0;
> value = default_value;
> return 0;
> }
>
>
> template <typename T>
> err_t read_ref(const std::string& name,T& value)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> err_t err = 0;
> if (!dom->enter(name)) return 0x0a01;
> err = value.read(*this,name);
> dom->leave();
> return err;
> }
>
>
> template <typename T>
> err_t read_ptr(const std::string& name,const std::string& type,T& value,T default_value=__null)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> err_t err = 0;
> if (!dom->enter(name)) return 0x0a01;
> value = static_cast<T>(factory->new_product(type));
> if (!value)
> {
> dom->leave();
> return 0x0a02;
> }
> if (default_value)
> {
> *value = *default_value;
> def = true;
> }
> err = value->read(*this,name);
> def = false;
> if (err || name == "Error")
> {
> if (value) delete value;
> value = __null;
> }
> dom->leave();
> return err;
> }
>
> template <typename T>
> void delete_ptr(T& value)
> {
> FMR::Platform::Lock<LockModel> lock(mx_brw);
> factory->delete_product(value);
> }
>
>
> private:
> XmlDom* dom;
> BrowserSpecs::TypeManager* factory;
> bool def;
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_brw;
> };
>
> }
>
>}
># 23 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrProduct.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrFormatter.h" 1
># 20 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrFormatter.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrMarshaller.h" 1
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iostream" 1 3
># 41 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iostream" 3
> 
># 42 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iostream" 3
>
>
>
>
>
>namespace std
>{
># 62 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iostream" 3
> extern istream cin;
> extern ostream cout;
> extern ostream cerr;
> extern ostream clog;
>
>
> extern wistream wcin;
> extern wostream wcout;
> extern wostream wcerr;
> extern wostream wclog;
>
>
>
>
> static ios_base::Init __ioinit;
>}
># 9 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrMarshaller.h" 2
>
>
>namespace FMR {
>
> namespace Streaming {
>
> class Marshaller
> {
> public:
>
> Marshaller(std::ostream& stream,char marker,size_t max_indent)
> : out(stream), space(std::string(1,marker)+" "), width(max_indent) {out.precision(12);}
> virtual ~Marshaller() {}
>
> void newline(void) {out << std::endl;}
> void indent(const std::string& label="") {out << std::string(space+label).substr(0,width);}
> template <typename T> void marshal(const T& x) {out << x;}
>
> private:
> std::ostream& out;
> std::string space;
> size_t width;
> };
>
>
> class MarshallerHolder
> {
> public:
> MarshallerHolder(Marshaller& stream) : mr(stream) {}
> virtual ~MarshallerHolder() {}
>
> Marshaller mr;
> };
>
> }
>
>}
># 21 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrFormatter.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrStyleSheet.h" 1
># 10 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrStyleSheet.h"
>namespace FMR {
>
> namespace Streaming {
>
> class StyleSheet
> {
> public:
> StyleSheet() {}
> virtual ~StyleSheet() {}
>
> virtual void enter(const std::string& label) =0;
> virtual void leave(const std::string& label) =0;
> virtual void comment(const std::string& comment) =0;
> template <typename T>
> void write(const std::string& label,const T& value) {trace(label,value);}
>
> private:
> virtual void trace(const std::string& label,char value) =0;
> virtual void trace(const std::string& label,unsigned char value) =0;
> virtual void trace(const std::string& label,short value) =0;
> virtual void trace(const std::string& label,unsigned short value) =0;
> virtual void trace(const std::string& label,int value) =0;
> virtual void trace(const std::string& label,unsigned int value) =0;
> virtual void trace(const std::string& label,long value) =0;
> virtual void trace(const std::string& label,unsigned long value) =0;
> virtual void trace(const std::string& label,float value) =0;
> virtual void trace(const std::string& label,double value) =0;
> virtual void trace(const std::string& label,const char* value) =0;
> virtual void trace(const std::string& label,const std::string& value) =0;
> };
>
> }
>
>}
># 22 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/streaming/fmrFormatter.h" 2
>
>
>namespace FMR {
>
> namespace Streaming {
>
> class Formatter
> {
> public:
>
>
>
>
> template <typename Style>
> Formatter(const Style& style,std::ostream& stream,char marker,size_t max_indent)
> : mr(stream,marker,max_indent) {ss = style.new_sheet(mr);}
>
> virtual ~Formatter() {if(ss) delete ss;}
>
>
>
>
>
> void enter(const std::string& name) {ss->enter(name);}
>
> void leave(const std::string& name) {ss->leave(name);}
>
> void comment(const std::string& comment) {ss->comment(comment);}
>
>
>
>
>
> template <typename T>
> void write(const std::string& name,const T& value) {ss->write(name,value);}
>
> template <typename T>
> void write_ref(const std::string& name,const T& value)
> {
> enter(name);
> value.write(*this,name);
> leave(name);
> }
>
> template <typename T>
> void write_ptr(const std::string& name,const T& value)
> {
> enter(name);
> value->write(*this,name);
> leave(name);
> }
>
>
> private:
> Marshaller mr;
> StyleSheet* ss;
> };
>
> }
>
>}
># 24 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrProduct.h" 2
>
>
>namespace FMR4000 {
>
> namespace Service {
>
> namespace ProductSpecs {
>
> const std::string UnknownId = "Unknown";
>
> }
>
>
> class Form
> {
> public:
> Form(void) {}
> virtual ~Form() {}
>
>
>
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const {}
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name) {return 0;}
>
> };
>
>
> class BuildData;
>
> class Product : public Form
> {
> public:
>
>
>
>
> Product(const std::string& type) : id(type) {}
>
> Product(const Product& that) : id(that.id) {}
>
> Product& operator=(const Product& that)
> {
> if(&that!=this) id=that.id;
> return *this;
> }
>
> virtual ~Product() {}
>
>
>
>
>
> const std::string& query(void) const {return id;}
>
> virtual Product* clone(void) const {return new Product(id);}
>
> virtual Product* duplicate(void) const {return new Product(id);}
>
> virtual err_t validate(void) const {return 0;}
>
> virtual err_t build(BuildData* data) {return 0;}
>
>
> private:
> std::string id;
> Product(void) {}
> };
>
> }
>
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrBaseObject.h" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrBaseMT.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrLockModel.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrBaseMT.h" 2
>
>namespace FMR {
>
> namespace Platform {
>
> template
> <
> typename ReadPolicy = PollReading<>,
> typename ThreadModel = DefaultThreadTrait
> >
> class BaseMT : public TwoLevelLocker<ReadPolicy,ThreadModel>,
> public Barrier<ThreadModel>,
> public ReferenceCounter<ThreadModel>
> {
> public:
>
>
>
> BaseMT(void)
> : TwoLevelLocker<ReadPolicy,ThreadModel>(),
> Barrier<ThreadModel>(),
> ReferenceCounter<ThreadModel>() {}
>
> virtual ~BaseMT() {}
>
> };
>
> }
>
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrBaseObject.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrProxy.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrHandle.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrLock.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrHandle.h" 2
>
>
>namespace FMR {
>
> namespace Platform {
>
> template
> <
> typename Interface,
> typename LockModel,
> typename AccessType
> >
> class ExternalLock : public Lock<LockModel,AccessType>
> {
> public:
>
> typedef Interface* Pointer;
>
>
>
>
> ExternalLock(Pointer obj,LockModel* model) : Lock<LockModel,AccessType>(model), pointee(obj) {}
>
> ExternalLock(ExternalLock& that) {copy(that);}
>
> ExternalLock& operator=(ExternalLock& that) {if (&that!=this) {this->blank(); copy(that);} return *this;}
>
> virtual ~ExternalLock() {}
>
>
>
>
>
> Pointer operator->();
>
>
> private:
> Pointer pointee;
> void copy(ExternalLock& that);
> };
>
>
> template
> <
> typename Interface,
> typename LockModel,
> typename RefModel,
> typename AccessType
> >
> class Handle
> {
> public:
>
> typedef ExternalLock<Interface,LockModel,AccessType> LockProxy;
>
> typedef typename LockProxy::Pointer Pointer;
>
>
>
>
> Handle(void) : pointee(__null), locker(__null), counter(__null) {}
>
> Handle(Pointer object);
>
> Handle(Pointer object,LockModel* lock_model,RefModel* ref_model);
>
> Handle(const Handle& that) {copy(that);}
>
> Handle& operator=(const Handle& that) {if (&that!=this) {blank(); copy(that);} return *this;}
>
> virtual ~Handle() {blank();}
>
>
>
>
>
> bool operator!() volatile {return __null==pointee;}
>
> operator bool() volatile {return __null!=pointee;}
>
> LockProxy operator->();
>
> LockProxy operator->() const;
>
> template <typename UI,typename AT>
> Handle<UI,LockModel,RefModel,AT> clone(const UI*,const AT&)
> {
> if (!pointee) return Handle<UI,LockModel,RefModel,AT>();
>
> typedef UI* UserPtr;
> UserPtr user_pointee = static_cast<UI*>(pointee);
> return Handle<UI,LockModel,RefModel,AT>(user_pointee,locker,counter);
> }
>
>
> private:
> Pointer pointee;
> LockModel* locker;
> RefModel* counter;
>
> void blank(void);
> void copy(const Handle& that);
> };
>
> }
>
>}
>
>
>template <typename If,typename LM,typename AT>
>inline If* FMR::Platform::ExternalLock<If,LM,AT>::operator->()
>{
> return pointee;
>}
>
>
>template <typename If,typename LM,typename AT>
>inline void FMR::Platform::ExternalLock<If,LM,AT>::copy(ExternalLock& that)
>{
> Lock<LM,AT>::copy(that);
> pointee = that.pointee;
> that.pointee = __null;
>}
>
>
>template <typename If,typename LM,typename RM,typename AT>
>inline FMR::Platform::Handle<If,LM,RM,AT>::Handle(Pointer object)
> : pointee(object)
>{
> locker = static_cast<LM*>(const_cast<If*>(object));
> counter = static_cast<LM*>(const_cast<If*>(object));
>
> counter->increment();
>}
>
>
>template <typename If,typename LM,typename RM,typename AT>
>inline FMR::Platform::Handle<If,LM,RM,AT>::Handle(Pointer object,LM* lock_model,RM* ref_model)
> : pointee(object), locker(lock_model), counter(ref_model)
>{
>
> counter->increment();
>}
>
>
>template <typename If,typename LM,typename RM,typename AT>
>inline typename FMR::Platform::Handle<If,LM,RM,AT>::LockProxy FMR::Platform::Handle<If,LM,RM,AT>::operator->()
>{
> LockProxy tmp(pointee,locker);
> return tmp;
>}
>
>
>template <typename If,typename LM,typename RM,typename AT>
>inline typename FMR::Platform::Handle<If,LM,RM,AT>::LockProxy FMR::Platform::Handle<If,LM,RM,AT>::operator->() const
>{
> LockProxy tmp(pointee,locker);
> return tmp;
>}
>
>
>template <typename If,typename LM,typename RM,typename AT>
>inline void FMR::Platform::Handle<If,LM,RM,AT>::blank(void)
>{
>
> if (counter) counter->decrement();
>
> pointee = __null;
> locker = __null;
> counter = __null;
>}
>
>
>template <typename If,typename LM,typename RM,typename AT>
>inline void FMR::Platform::Handle<If,LM,RM,AT>::copy(const Handle& that)
>{
>
> pointee = that.pointee;
> locker = that.locker;
> counter = that.counter;
>
> if (counter) counter->increment();
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrProxy.h" 2
>
>namespace FMR {
>
> namespace Platform {
>
> template
> <
> typename Interface,
> typename LockModel,
> typename RefModel
> >
> class Proxy
> {
> public:
>
>
>
> Proxy(Interface* object,LockModel& lock_model,RefModel& ref_model);
>
> Proxy(Interface* object);
>
> virtual ~Proxy();
>
>
>
>
>
> bool is_equivalent(const Proxy* that);
>
>
>
>
>
> void signal(const Signals::Kill&);
>
> template <typename UserIf,typename AccessType>
> Handle<UserIf,LockModel,RefModel,AccessType> new_handle(const UserIf* ui,const AccessType& at)
> {
> if (proto)
> {
> if (!locker->is_active())
> return const_cast<Prototype*>(proto)->clone(ui,at);
> else
> blank();
> }
>
>
> return Handle<UserIf,LockModel,RefModel,AccessType>();
> }
>
>
> private:
> typedef Handle<Interface,LockModel,RefModel,Access::Generic> Prototype;
>
> Interface* pointee;
> LockModel* locker;
> RefModel* counter;
>
> volatile Prototype* proto;
>
> void init(RefModel* counter);
> void blank(void);
> void copy(Proxy& that);
>
> Proxy(void) {}
> Proxy(const Proxy& that) {}
> Proxy& operator=(const Proxy& that) {return *this;}
> };
>
> }
>
>}
>
>
>template <typename If,typename LM,typename RM>
>inline FMR::Platform::Proxy<If,LM,RM>::Proxy(If* object,LM& lock_model,RM& ref_model)
> : proto(__null), pointee(object), locker(&lock_model), counter(&ref_model)
>{
> init(&ref_model);
>}
>
>
>template <typename If,typename LM,typename RM>
>inline FMR::Platform::Proxy<If,LM,RM>::Proxy(If* object)
> : proto(__null), pointee(object), locker(static_cast<LM*>(object)), counter(static_cast<LM*>(object))
>{
> init(static_cast<RM*>(object));
>}
>
>
>template <typename If,typename LM,typename RM>
>inline FMR::Platform::Proxy<If,LM,RM>::~Proxy(void)
>{
> blank();
>}
>
>
>template <typename If,typename LM,typename RM>
>inline void FMR::Platform::Proxy<If,LM,RM>::init(RM* counter)
>{
> proto = new Prototype(pointee,locker,counter);
>}
>
>
>template <typename If,typename LM,typename RM>
>inline bool FMR::Platform::Proxy<If,LM,RM>::is_equivalent(const Proxy* that)
>{
> return pointee==that->pointee && pointee!=__null;
>}
>
>
>template <typename If,typename LM,typename RM>
>inline void FMR::Platform::Proxy<If,LM,RM>::signal(const Signals::Kill&)
>{
> if (!proto) return;
> locker->shield();
> blank();
>}
>
>
>template <typename If,typename LM,typename RM>
>inline void FMR::Platform::Proxy<If,LM,RM>::blank(void)
>{
> volatile Prototype* tmp = proto;
> proto = __null;
> if(tmp) delete tmp;
>}
># 8 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrBaseObject.h" 2
>
>
>namespace FMR4000 {
>
> namespace Service {
>
> namespace BufferType {
>
> const std::string Unknown = "unknown";
> const std::string Standard = "std";
>
> }
>
>
> namespace FactoryType {
>
> const std::string Unknown = "Unknown";
>
> }
>
>
> class BaseObj : public Service::Product,
> public FMR::Platform::BaseMT
> <
> FMR::Platform::PollReading<>,
> FMR::Platform::DefaultThreadTrait
> >
> {
> public:
>
> typedef FMR::Platform::BaseMT
> <
> FMR::Platform::PollReading<>,
> FMR::Platform::DefaultThreadTrait
> > MTPolicy;
>
>
>
>
> BaseObj(const std::string& type) : Product(type), MTPolicy() {}
>
> virtual ~BaseObj() {}
>
>
>
>
>
> virtual Service::Product* clone(void) const {return new BaseObj(query());}
>
> virtual Service::Product* duplicate(void) const {return new BaseObj(query());}
>
> };
>
>
> typedef FMR::Platform::Proxy
> <
> BaseObj,
> BaseObj,
> BaseObj
> > ProxyType;
>
> template <typename PT>
> class ProxyObj
> {
> public:
>
>
>
> ProxyObj(BaseObj* obj);
>
> virtual ~ProxyObj();
>
> inline err_t init(const std::string& name,const std::string& type,const std::string& factory_type=FactoryType::Unknown);
>
>
> operator PT* () const;
>
> private:
> BaseObj* obj;
> PT* px;
> };
>
>
> namespace AccessPolicies {
>
> template
> <
> typename AT
> >
> class JustInTime
> {
> public:
> JustInTime(void) {}
> virtual ~JustInTime() {}
>
> typedef AT AccessType;
>
> static void* open(ProxyType* proxy) {return __null;}
> static void close(void* token) {}
> };
>
> }
>
>
> typedef AccessPolicies::JustInTime
> <
> FMR::Platform::Access::ReadOnly
> > ReadOnly;
>
> typedef AccessPolicies::JustInTime
> <
> FMR::Platform::Access::ReadWrite
> > ReadWrite;
>
>
> template
> <
> typename Object,
> typename AccessPolicy
> >
> class AccessObj
> {
> public :
>
>
>
>
> typedef FMR::Platform::Handle
> <
> Object,
> BaseObj,
> BaseObj,
> typename AccessPolicy::AccessType
> > Handle;
>
>
>
>
>
> AccessObj(void);
>
> AccessObj(ProxyType* proxy);
>
>
>
> AccessObj(BaseObj* obj);
>
> virtual ~AccessObj();
>
> err_t init(const std::string& name,const std::string& type,const std::string& factory_type);
>
>
>
>
>
> err_t assign(ProxyType* proxy);
>
> err_t assign(const std::string& name,const std::string& type,const std::string& factory_type=FactoryType::Unknown);
>
>
>
>
>
> err_t blank(void);
>
> operator ProxyType*(void) const;
>
> bool operator!(void) const;
>
> operator bool(void) const;
>
>
>
>
>
> Handle get_handle(void);
>
> static Handle get_handle(ProxyType* proxy);
>
> static err_t get_handle(const std::string& name,const std::string& type,Handle& handle,const std::string& factory_type=FactoryType::Unknown);
>
> static err_t get_handle(const std::string& name,const std::string& type,BaseObj*& obj,Handle& handle);
>
> static bool handle_type(const Handle& h, const std::string& factory_type);
>
>
> private:
> void* token;
> bool own_proxy;
> BaseObj* obj;
> ProxyType* px;
>
> AccessObj(const AccessObj&);
> AccessObj& operator=(const AccessObj&);
> };
>
> namespace DirectorSpecs {
>
> class ManagerImpl;
>
> }
>
>
> class ObjectManager
> {
> public:
>
>
>
>
> ObjectManager(void);
>
> virtual ~ObjectManager();
>
>
>
>
>
> const char* last_error(void) const;
>
> bool is_std(const std::string &name,const std::string &type,std::string& bt_name) const;
>
> err_t update(std::string& xml_request,BaseObj*& obj);
>
>
>
>
>
> err_t get(const std::string& name,ProxyType*& px,const std::string& type,const std::string& factory_type=FactoryType::Unknown);
>
> err_t put(ProxyType*& proxy);
>
> err_t connect(BaseObj* from,const std::string& to,ProxyType*& px,const std::string& type,const std::string& factory_type=FactoryType::Unknown);
>
> err_t disconnect(const BaseObj *from,ProxyType *to);
>
> err_t insert(const std::string &name,const std::string &type,BaseObj* obj,ProxyType*& px);
>
> err_t remove(const std::string& name,const std::string& type=BufferType::Unknown);
>
> err_t refresh(const std::string& name = BufferType::Unknown);
>
> err_t build(const std::string& name,const std::string& data,BaseObj*& obj);
>
>
> private:
> DirectorSpecs::ManagerImpl* impl;
> };
>
> ObjectManager& Director(void);
>
> }
>
>}
>
>
>template <typename PT>
>inline FMR4000::Service::ProxyObj<PT>::ProxyObj(BaseObj* object)
> : px(__null), obj(object)
>{
>
>}
>
>
>template <typename PT>
>inline err_t FMR4000::Service::ProxyObj<PT>::init(const std::string& name,const std::string& type,const std::string& factory_type)
>{
> err_t err = 0;
> if (obj)
> err = FMR4000::Service::Director().connect(obj,name,px,type);
> else
> err = FMR4000::Service::Director().get(name,px,type,factory_type);
> return err;
>}
>
>
>template <typename PT>
>inline FMR4000::Service::ProxyObj<PT>::~ProxyObj(void)
>{
> err_t err = 0;
> if (obj)
> err = FMR4000::Service::Director().disconnect(obj,px);
> else
> err = FMR4000::Service::Director().put(px);
>
>}
>
>
>template <typename PT>
>inline FMR4000::Service::ProxyObj<PT>::operator PT* () const
>{
> return px;
>}
>
>
>template <typename O,typename AP>
>inline FMR4000::Service::AccessObj<O,AP>::AccessObj(void)
> : token(__null), own_proxy(false), obj(__null), px(__null)
>{
>}
>
>
>template <typename O,typename AP>
>inline FMR4000::Service::AccessObj<O,AP>::AccessObj(ProxyType* proxy)
> : token(__null), own_proxy(false), obj(__null), px(proxy)
>{
> token = AP::open(px);
>}
>
>
>template <typename O,typename AP>
>inline FMR4000::Service::AccessObj<O,AP>::AccessObj(BaseObj* object)
> : token(__null), own_proxy(true), obj(object), px(__null)
>{
>
>}
>
>
>template <typename O,typename AP>
>inline err_t FMR4000::Service::AccessObj<O,AP>::init(const std::string& name,const std::string& type,const std::string& factory_type)
>{
> err_t err = 0;
> if (obj)
> {
> err = FMR4000::Service::Director().connect(obj,name,px,type,factory_type);
> if (err) return err;
> token = AP::open(px);
> }
> else
> {
> err = FMR4000::Service::Director().get(name,px,type,factory_type);
> if (err) return err;
> token = AP::open(px);
> }
> return err;
>}
>
>
>template <typename O,typename AP>
>inline FMR4000::Service::AccessObj<O,AP>::~AccessObj(void)
>{
> blank();
>}
>
>
>template <typename O,typename AP>
>inline err_t FMR4000::Service::AccessObj<O,AP>::blank(void)
>{
> err_t err = 0;
> AP::close(token);
> if (own_proxy)
> {
> if (obj)
> err = FMR4000::Service::Director().disconnect(obj,px);
> else
> err = FMR4000::Service::Director().put(px);
> }
> px = __null;
> return err;
>}
>
>
>template <typename O,typename AP>
>inline FMR4000::Service::AccessObj<O,AP>::operator FMR4000::Service::ProxyType*(void) const
>{
> return px;
>}
>
>
>template <typename O,typename AP>
>inline bool FMR4000::Service::AccessObj<O,AP>::operator!(void) const
>{
> return !px;
>}
>
>
>template <typename O,typename AP>
>inline FMR4000::Service::AccessObj<O,AP>::operator bool(void) const
>{
> return !!px;
>}
>
>
>template <typename O,typename AP>
>inline err_t FMR4000::Service::AccessObj<O,AP>::assign(ProxyType* proxy)
>{
> err_t err = blank();
> if (err) return err;
> px = proxy;
> own_proxy = false;
> token = AP::open(px);
> return err;
>}
>
>
>template <typename O,typename AP>
>inline err_t FMR4000::Service::AccessObj<O,AP>::assign(const std::string& name,const std::string& type,const std::string& factory_type)
>{
> err_t err = blank();
> if (err) return err;
> err = FMR4000::Service::Director().get(name,px,type,factory_type);
> if (err) return err;
> own_proxy = true;
> token = AP::open(px);
> return err;
>}
>
>
>template <typename O,typename AP>
>inline typename FMR4000::Service::AccessObj<O,AP>::Handle FMR4000::Service::AccessObj<O,AP>::get_handle(void)
>{
> if(!px) return Handle();
> O* dummy = __null;
> typedef typename AP::AccessType AccessType;
> return px->new_handle(dummy,AccessType());
>}
>
>
>template <typename O,typename AP>
>inline typename FMR4000::Service::AccessObj<O,AP>::Handle FMR4000::Service::AccessObj<O,AP>::get_handle(ProxyType* proxy)
>{
> if (!proxy) return Handle();
> O* dummy = __null;
> typedef typename AP::AccessType AccessType;
> Handle handle = proxy->new_handle(dummy,AccessType());
> return handle;
>}
>
>
>template <typename O,typename AP>
>inline err_t FMR4000::Service::AccessObj<O,AP>::get_handle(const std::string& name,const std::string& type,typename FMR4000::Service::AccessObj<O,AP>::Handle& handle,const std::string& factory_type)
>{
> err_t err = 0;
> ProxyType* proxy = __null;
> err = FMR4000::Service::Director().get(name,proxy,type,factory_type);
> if (err) return err;
> O* dummy = __null;
> typedef typename AP::AccessType AccessType;
> handle = proxy->new_handle(dummy,AccessType());
> err = FMR4000::Service::Director().put(proxy);
> return err;
>}
>
>template <typename O,typename AP>
>inline err_t FMR4000::Service::AccessObj<O,AP>::get_handle(const std::string& name,const std::string& type,BaseObj*& obj,typename FMR4000::Service::AccessObj<O,AP>::Handle& handle)
>{
> err_t err = 0;
> ProxyType* proxy = __null;
> err = FMR4000::Service::Director().build(name,"",obj);
> if (err) return err;
> err = FMR4000::Service::Director().insert(name,type,obj,proxy);
> if (err) return err;
> O* dummy = __null;
> typedef typename AP::AccessType AccessType;
> handle = proxy->new_handle(dummy,AccessType());
> err = FMR4000::Service::Director().put(proxy);
> return err;
>}
>
>template <typename O,typename AP>
>inline bool FMR4000::Service::AccessObj<O,AP>::handle_type(const Handle& h, const std::string& factory_type)
>{
> return h->query()==factory_type;
>}
># 53 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtAlgo.h" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrBox.h" 1
># 10 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrBox.h"
>namespace FMR {
>
> namespace Platform {
>
> namespace BoxPolicies {
>
> class DuplicateObject
> {
> public:
> DuplicateObject(void) {}
> virtual ~DuplicateObject() {}
>
> template <typename T>
> static T* copy(const T* ptr) {return static_cast<T*>(ptr->duplicate());}
> };
>
> class StoreReference
> {
> public:
> StoreReference(void) {}
> virtual ~StoreReference() {}
>
> template <typename T>
> static T* copy(const T* ptr) {return const_cast<T*>(ptr);}
> };
>
> }
>
>
> template
> <
> typename _Type,
> typename _Policy=BoxPolicies::DuplicateObject
> >
> class Box
> {
> public:
> typedef _Type* Pointer;
> typedef _Type const* ConstPointer;
>
> Box(void) : is_owner(false), p(__null) {}
> Box(Box& that) {copy(that.p,that.is_owner);}
> Box& operator=(Box& that) {if (&that!=this) {set(that.p,that.is_owner);} return *this;}
> virtual ~Box() {blank();}
>
> bool operator!(void) const {return !p;}
> operator bool (void) const {return !!p;}
> operator Pointer (void) const {return p;}
>
> Pointer operator->(void) {return p;}
> const Pointer operator->(void) const {return p;}
>
> void set(ConstPointer ptr,bool own_memory) {blank(); copy(const_cast<Pointer>(ptr),own_memory);}
> void clear(void) {blank();}
>
> private:
> bool is_owner;
> Pointer p;
> typedef FMR::Platform::OnOffLocker<> LockModel;
> LockModel mx_box;
>
> void blank(void);
> void copy(Pointer ptr,bool own_memory);
> };
>
> }
>
>}
>
>
>template <typename T,typename P>
>inline void FMR::Platform::Box<T,P>::blank(void)
>{
> FMR::Platform::Lock<LockModel> lock(mx_box);
> if (is_owner && p)
> {
> delete p;
> p = __null;
> }
>}
>
>template <typename T,typename P>
>inline void FMR::Platform::Box<T,P>::copy(Pointer ptr,bool own_memory)
>{
> FMR::Platform::Lock<LockModel> lock(mx_box);
> if (ptr && own_memory)
> {
> p = P::copy(ptr);
> }
> else
> {
> p = ptr;
> }
> is_owner = own_memory;
>}
># 55 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtAlgo.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace LegSpecs {
>
> class Entry;
>
> }
>
>
> namespace InstrSpecs {
>
> class Entry;
>
> }
>
> class RunTimeAlgo : public Service::Product
> {
> public:
>
>
>
>
>
>
>
> const InstrSpecs::Entry* ref_instr_entry;
>
>
>
>
> RunTimeAlgo& operator=(const RunTimeAlgo& that);
>
> virtual ~RunTimeAlgo();
>
>
>
>
>
> const std::string& query_algo(void) const;
>
> virtual Service::Product* clone(void) const =0;
>
> virtual Service::Product* duplicate(void) const =0;
>
>
>
>
>
> virtual err_t validate(void) const =0;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
> virtual err_t check_varg(const std::string& prefix, Service::ProxyType* pxvarg);
>
> virtual err_t update(
> const std::string& prefix,
>
> long trade,
>
> long settlement,
>
> const InstrSpecs::Entry* instr_entry,
>
> Service::ProxyType* pxvarg) =0;
>
> virtual err_t substitute(Service::ProxyType* pxold,Service::ProxyType* pxnew);
>
> virtual err_t set_leg(const InstrSpecs::Entry* instr_entry) const =0;
>
> virtual err_t calculate(LegSpecs::Entry* leg_entry) const =0;
>
>
> protected:
>
> RunTimeAlgo(const std::string& type,const std::string& name);
>
> RunTimeAlgo(const std::string& type,
> const std::string& name,
> const InstrSpecs::Entry* instr_entry);
>
> virtual void assign(const RunTimeAlgo& that) =0;
>
> private:
> std::string algo_type;
> };
>
> class RtAlgo : public FMR::Platform::Box<RunTimeAlgo>
> {
> public:
> typedef FMR::Platform::Box<RunTimeAlgo> AlgoBox;
> RtAlgo* next;
> RtAlgo(void);
> RtAlgo(RtAlgo& that);
> RtAlgo& operator=(RtAlgo& that);
> virtual ~RtAlgo();
> void* get_algo_by_id(std::string algo_id);
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_rta;
> };
>
> }
>
>}
># 6 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/option/fmrBasketPricer.h" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrMatrix.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/os/fmrOS.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrMatrix.h" 2
># 21 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrMatrix.h"
># 1 "/usr/local/include/mtl/mtl.h" 1 3
># 17 "/usr/local/include/mtl/mtl.h" 3
># 1 "/usr/local/include/mtl/mtl_decl.h" 1 3
># 11 "/usr/local/include/mtl/mtl_decl.h" 3
># 1 "/usr/local/include/mtl/matrix_traits.h" 1 3
>
>
>
># 1 "/usr/local/include/mtl/mtl_complex.h" 1 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 1 3
># 45 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> 
># 46 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 1 3
># 48 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 3
> 
># 49 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 3
>
>
>
>
># 1 "/usr/include/math.h" 1 3 4
># 30 "/usr/include/math.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 35 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 37 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 38 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 41 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 44 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 36 "/usr/include/bits/mathdef.h" 3 4
>typedef long double float_t;
>
>typedef long double double_t;
># 48 "/usr/include/math.h" 2 3 4
># 71 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
>
>extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
>
>extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
>
>extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
>
>
>extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
>
>extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
>
>extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
>
>
>
>
>extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
>
>extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
>
>extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
>
>
>
>
>
>
>extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
>
>extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
>
>extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
>
>
>
>
>
>
>
>extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
>
>
>extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
>
>
>extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
>
>
>extern double log (double __x) throw (); extern double __log (double __x) throw ();
>
>
>extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
>
>
>extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();
>
>
>
>
>extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
>
>extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
>
>
>
>
>
>extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
>
>
>extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
>
>
>extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
>
>
>
>
>
>
>extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
>
>
>extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
>
>
>extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
>
>
>
>
>
>extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
>
>
>
>
>
>
>extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
>
>
>extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
>
>
>
>
>extern int __isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finite (double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
>
>
>
>extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
>
>
>
>
>
>extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) throw () __attribute__ ((__const__));
>
>
>extern double j0 (double) throw (); extern double __j0 (double) throw ();
>extern double j1 (double) throw (); extern double __j1 (double) throw ();
>extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
>extern double y0 (double) throw (); extern double __y0 (double) throw ();
>extern double y1 (double) throw (); extern double __y1 (double) throw ();
>extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
>
>
>
>
>
>
>extern double erf (double) throw (); extern double __erf (double) throw ();
>extern double erfc (double) throw (); extern double __erfc (double) throw ();
>extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
>
>
>
>
>
>
>extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
>
>
>
>
>
>extern double gamma (double) throw (); extern double __gamma (double) throw ();
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
>
>
>extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
>
>
>
>extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
>
>
>
>extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
>
>
>
>
>extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
>
>
>
>extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
>
>
>
>extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
>extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
>
>
>
>extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
>extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
>
>
>
>extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
>
>
>extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();
>
>
>extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();
>
>
>
>extern int __fpclassify (double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
>
>
>
>
>
>
>
>
>extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
># 72 "/usr/include/math.h" 2 3 4
># 94 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
>
>extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
>
>extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
>
>extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
>
>
>extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
>
>extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
>
>extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
>
>
>
>
>extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
>
>extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
>
>extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
>
>
>
>
>extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
>
>
>
>
>
>
>extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
>
>extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
>
>extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
>
>
>
>
>
>
>
>extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
>
>
>extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
>
>
>extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
>
>
>extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
>
>
>extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
>
>
>extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();
>
>
>
>
>extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
>
>extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
>
>
>
>
>
>extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
>
>
>extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
>
>
>extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
>
>
>
>
>
>
>extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
>
>
>extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
>
>
>extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
>
>
>
>
>
>extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
>
>
>
>
>
>
>extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
>
>
>
>
>extern int __isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
>
>
>
>extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
>
>
>
>
>
>extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>extern float j0f (float) throw (); extern float __j0f (float) throw ();
>extern float j1f (float) throw (); extern float __j1f (float) throw ();
>extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
>extern float y0f (float) throw (); extern float __y0f (float) throw ();
>extern float y1f (float) throw (); extern float __y1f (float) throw ();
>extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
>
>
>
>
>
>
>extern float erff (float) throw (); extern float __erff (float) throw ();
>extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
>extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
>
>
>
>
>
>
>extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
>
>
>
>
>
>extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
>
>
>extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
>
>
>
>extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
>
>
>
>extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
>
>
>
>
>extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
>
>
>
>extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
>
>
>
>extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
>extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
>
>
>
>extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
>extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
>
>
>
>extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
>
>
>extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();
>
>
>extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();
>
>
>
>extern int __fpclassifyf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
>
>
>
>
>
>
>
>
>extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
># 95 "/usr/include/math.h" 2 3 4
># 141 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
>
>extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
>
>extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
>
>extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
>
>
>extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
>
>extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
>
>extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
>
>
>
>
>extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
>
>extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
>
>extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
>
>
>
>
>extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
>
>
>
>
>
>
>extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
>
>extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
>
>extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
>
>
>
>
>
>
>
>extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
>
>
>extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
>
>
>extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
>
>
>extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
>
>
>extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
>
>
>extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();
>
>
>
>
>extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
>
>extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
>
>
>
>
>
>extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
>
>
>extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
>
>
>extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
>
>
>
>
>
>
>extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
>
>
>extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
>
>
>extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
>
>
>
>
>
>
>extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
>
>
>
>
>extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
>
>
>
>extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
>extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
>extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
>extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
>extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
>extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
>
>
>
>
>
>
>extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
>extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
>extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
>
>
>
>
>
>
>extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
>
>
>
>
>
>extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
>
>
>extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
>
>
>
>extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
>
>
>
>extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
>
>
>
>extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
>
>
>
>extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
>extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
>
>
>
>extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
>extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
>
>
>
>extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
>
>
>extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();
>
>
>extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();
>
>
>
>extern int __fpclassifyl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
>
>
>
>
>
>
>
>
>extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
># 142 "/usr/include/math.h" 2 3 4
># 157 "/usr/include/math.h" 3 4
>extern int signgam;
># 198 "/usr/include/math.h" 3 4
>enum
> {
> FP_NAN,
>
> FP_INFINITE,
>
> FP_ZERO,
>
> FP_SUBNORMAL,
>
> FP_NORMAL
>
> };
># 284 "/usr/include/math.h" 3 4
>typedef enum
>{
> _IEEE_ = -1,
> _SVID_,
> _XOPEN_,
> _POSIX_,
> _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 307 "/usr/include/math.h" 3 4
>struct __exception
>
>
>
> {
> int type;
> char *name;
> double arg1;
> double arg2;
> double retval;
> };
>
>
>extern int matherr (struct __exception *__exc) throw ();
># 409 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 127 "/usr/include/bits/mathinline.h" 3 4
>__inline int
>__signbitf (float __x) throw ()
>{
> __extension__ union { float __f; int __i; } __u = { __f: __x };
> return __u.__i < 0;
>}
>__inline int
>__signbit (double __x) throw ()
>{
> __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
> return __u.__i[1] < 0;
>}
>__inline int
>__signbitl (long double __x) throw ()
>{
> __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
> return (__u.__i[2] & 0x8000) != 0;
>}
># 410 "/usr/include/math.h" 2 3 4
># 465 "/usr/include/math.h" 3 4
>}
># 54 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 2 3
># 82 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 3
>namespace std
>{
>
>
> template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
>
> inline double
> abs(double __x)
> { return __builtin_fabs(__x); }
>
> inline float
> abs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline long double
> abs(long double __x)
> { return __builtin_fabsl(__x); }
>
> using ::acos;
>
> inline float
> acos(float __x)
> { return __builtin_acosf(__x); }
>
> inline long double
> acos(long double __x)
> { return __builtin_acosl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> acos(_Tp __x)
> {
> return __builtin_acos(__x);
> }
>
> using ::asin;
>
> inline float
> asin(float __x)
> { return __builtin_asinf(__x); }
>
> inline long double
> asin(long double __x)
> { return __builtin_asinl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> asin(_Tp __x)
> { return __builtin_asin(__x); }
>
> using ::atan;
>
> inline float
> atan(float __x)
> { return __builtin_atanf(__x); }
>
> inline long double
> atan(long double __x)
> { return __builtin_atanl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> atan(_Tp __x)
> { return __builtin_atan(__x); }
>
> using ::atan2;
>
> inline float
> atan2(float __y, float __x)
> { return __builtin_atan2f(__y, __x); }
>
> inline long double
> atan2(long double __y, long double __x)
> { return __builtin_atan2l(__y, __x); }
>
> template<typename _Tp, typename _Up>
> inline typename __enable_if<double, __is_integer<_Tp>::__value
> && __is_integer<_Up>::__value>::__type
> atan2(_Tp __y, _Up __x)
> { return __builtin_atan2(__y, __x); }
>
> using ::ceil;
>
> inline float
> ceil(float __x)
> { return __builtin_ceilf(__x); }
>
> inline long double
> ceil(long double __x)
> { return __builtin_ceill(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> ceil(_Tp __x)
> { return __builtin_ceil(__x); }
>
> using ::cos;
>
> inline float
> cos(float __x)
> { return __builtin_cosf(__x); }
>
> inline long double
> cos(long double __x)
> { return __builtin_cosl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> cos(_Tp __x)
> { return __builtin_cos(__x); }
>
> using ::cosh;
>
> inline float
> cosh(float __x)
> { return __builtin_coshf(__x); }
>
> inline long double
> cosh(long double __x)
> { return __builtin_coshl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> cosh(_Tp __x)
> { return __builtin_cosh(__x); }
>
> using ::exp;
>
> inline float
> exp(float __x)
> { return __builtin_expf(__x); }
>
> inline long double
> exp(long double __x)
> { return __builtin_expl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> exp(_Tp __x)
> { return __builtin_exp(__x); }
>
> using ::fabs;
>
> inline float
> fabs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline long double
> fabs(long double __x)
> { return __builtin_fabsl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> fabs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::floor;
>
> inline float
> floor(float __x)
> { return __builtin_floorf(__x); }
>
> inline long double
> floor(long double __x)
> { return __builtin_floorl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> floor(_Tp __x)
> { return __builtin_floor(__x); }
>
> using ::fmod;
>
> inline float
> fmod(float __x, float __y)
> { return __builtin_fmodf(__x, __y); }
>
> inline long double
> fmod(long double __x, long double __y)
> { return __builtin_fmodl(__x, __y); }
>
> using ::frexp;
>
> inline float
> frexp(float __x, int* __exp)
> { return __builtin_frexpf(__x, __exp); }
>
> inline long double
> frexp(long double __x, int* __exp)
> { return __builtin_frexpl(__x, __exp); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> frexp(_Tp __x, int* __exp)
> { return __builtin_frexp(__x, __exp); }
>
> using ::ldexp;
>
> inline float
> ldexp(float __x, int __exp)
> { return __builtin_ldexpf(__x, __exp); }
>
> inline long double
> ldexp(long double __x, int __exp)
> { return __builtin_ldexpl(__x, __exp); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> ldexp(_Tp __x, int __exp)
> { return __builtin_ldexp(__x, __exp); }
>
> using ::log;
>
> inline float
> log(float __x)
> { return __builtin_logf(__x); }
>
> inline long double
> log(long double __x)
> { return __builtin_logl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> log(_Tp __x)
> { return __builtin_log(__x); }
>
> using ::log10;
>
> inline float
> log10(float __x)
> { return __builtin_log10f(__x); }
>
> inline long double
> log10(long double __x)
> { return __builtin_log10l(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> log10(_Tp __x)
> { return __builtin_log10(__x); }
>
> using ::modf;
>
> inline float
> modf(float __x, float* __iptr)
> { return __builtin_modff(__x, __iptr); }
>
> inline long double
> modf(long double __x, long double* __iptr)
> { return __builtin_modfl(__x, __iptr); }
>
> template<typename _Tp>
> inline _Tp
> __pow_helper(_Tp __x, int __n)
> {
> return __n < 0
> ? _Tp(1)/__cmath_power(__x, -__n)
> : __cmath_power(__x, __n);
> }
>
> using ::pow;
>
> inline float
> pow(float __x, float __y)
> { return __builtin_powf(__x, __y); }
>
> inline long double
> pow(long double __x, long double __y)
> { return __builtin_powl(__x, __y); }
>
> inline double
> pow(double __x, int __i)
> { return __builtin_powi(__x, __i); }
>
> inline float
> pow(float __x, int __n)
> { return __builtin_powif(__x, __n); }
>
> inline long double
> pow(long double __x, int __n)
> { return __builtin_powil(__x, __n); }
>
> using ::sin;
>
> inline float
> sin(float __x)
> { return __builtin_sinf(__x); }
>
> inline long double
> sin(long double __x)
> { return __builtin_sinl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> sin(_Tp __x)
> { return __builtin_sin(__x); }
>
> using ::sinh;
>
> inline float
> sinh(float __x)
> { return __builtin_sinhf(__x); }
>
> inline long double
> sinh(long double __x)
> { return __builtin_sinhl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> sinh(_Tp __x)
> { return __builtin_sinh(__x); }
>
> using ::sqrt;
>
> inline float
> sqrt(float __x)
> { return __builtin_sqrtf(__x); }
>
> inline long double
> sqrt(long double __x)
> { return __builtin_sqrtl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> sqrt(_Tp __x)
> { return __builtin_sqrt(__x); }
>
> using ::tan;
>
> inline float
> tan(float __x)
> { return __builtin_tanf(__x); }
>
> inline long double
> tan(long double __x)
> { return __builtin_tanl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> tan(_Tp __x)
> { return __builtin_tan(__x); }
>
> using ::tanh;
>
> inline float
> tanh(float __x)
> { return __builtin_tanhf(__x); }
>
> inline long double
> tanh(long double __x)
> { return __builtin_tanhl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::__value>::__type
> tanh(_Tp __x)
> { return __builtin_tanh(__x); }
>}
>
>
>
>
>
>
>namespace __gnu_cxx
>{
> template<typename _Tp>
> inline int
> __capture_fpclassify(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __fpclassifyf (__f) : sizeof (__f) == sizeof (double) ? __fpclassify (__f) : __fpclassifyl (__f)); }
>
> template<typename _Tp>
> inline int
> __capture_isfinite(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __finitef (__f) : sizeof (__f) == sizeof (double) ? __finite (__f) : __finitel (__f)); }
>
> template<typename _Tp>
> inline int
> __capture_isinf(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __isinff (__f) : sizeof (__f) == sizeof (double) ? __isinf (__f) : __isinfl (__f)); }
>
> template<typename _Tp>
> inline int
> __capture_isnan(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __isnanf (__f) : sizeof (__f) == sizeof (double) ? __isnan (__f) : __isnanl (__f)); }
>
> template<typename _Tp>
> inline int
> __capture_isnormal(_Tp __f) { return ((sizeof (__f) == sizeof (float) ? __fpclassifyf (__f) : sizeof (__f) == sizeof (double) ? __fpclassify (__f) : __fpclassifyl (__f)) == FP_NORMAL); }
>
> template<typename _Tp>
> inline int
> __capture_signbit(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __signbitf (__f) : sizeof (__f) == sizeof (double) ? __signbit (__f) : __signbitl (__f)); }
>
> template<typename _Tp>
> inline int
> __capture_isgreater(_Tp __f1, _Tp __f2)
> { return __builtin_isgreater(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> __capture_isgreaterequal(_Tp __f1, _Tp __f2)
> { return __builtin_isgreaterequal(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> __capture_isless(_Tp __f1, _Tp __f2) { return __builtin_isless(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> __capture_islessequal(_Tp __f1, _Tp __f2)
> { return __builtin_islessequal(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> __capture_islessgreater(_Tp __f1, _Tp __f2)
> { return __builtin_islessgreater(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> __capture_isunordered(_Tp __f1, _Tp __f2)
> { return __builtin_isunordered(__f1, __f2); }
>}
># 515 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 3
>namespace std
>{
> template<typename _Tp>
> inline int
> fpclassify(_Tp __f) { return __gnu_cxx::__capture_fpclassify(__f); }
>
> template<typename _Tp>
> inline int
> isfinite(_Tp __f) { return __gnu_cxx::__capture_isfinite(__f); }
>
> template<typename _Tp>
> inline int
> isinf(_Tp __f) { return __gnu_cxx::__capture_isinf(__f); }
>
> template<typename _Tp>
> inline int
> isnan(_Tp __f) { return __gnu_cxx::__capture_isnan(__f); }
>
> template<typename _Tp>
> inline int
> isnormal(_Tp __f) { return __gnu_cxx::__capture_isnormal(__f); }
>
> template<typename _Tp>
> inline int
> signbit(_Tp __f) { return __gnu_cxx::__capture_signbit(__f); }
>
> template<typename _Tp>
> inline int
> isgreater(_Tp __f1, _Tp __f2)
> { return __gnu_cxx::__capture_isgreater(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> isgreaterequal(_Tp __f1, _Tp __f2)
> { return __gnu_cxx::__capture_isgreaterequal(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> isless(_Tp __f1, _Tp __f2)
> { return __gnu_cxx::__capture_isless(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> islessequal(_Tp __f1, _Tp __f2)
> { return __gnu_cxx::__capture_islessequal(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> islessgreater(_Tp __f1, _Tp __f2)
> { return __gnu_cxx::__capture_islessgreater(__f1, __f2); }
>
> template<typename _Tp>
> inline int
> isunordered(_Tp __f1, _Tp __f2)
> { return __gnu_cxx::__capture_isunordered(__f1, __f2); }
>}
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/cmath.tcc" 1 3
># 35 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/cmath.tcc" 3
>namespace std
>{
> template<typename _Tp>
> inline _Tp
> __cmath_power(_Tp __x, unsigned int __n)
> {
> _Tp __y = __n % 2 ? __x : 1;
>
> while (__n >>= 1)
> {
> __x = __x * __x;
> if (__n % 2)
> __y = __y * __x;
> }
>
> return __y;
> }
>}
># 576 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/cmath" 2 3
># 50 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 2 3
>
>
>namespace std
>{
>
> template<typename _Tp> class complex;
> template<> class complex<float>;
> template<> class complex<double>;
> template<> class complex<long double>;
>
>
> template<typename _Tp> _Tp abs(const complex<_Tp>&);
>
> template<typename _Tp> _Tp arg(const complex<_Tp>&);
>
> template<typename _Tp> _Tp norm(const complex<_Tp>&);
>
>
> template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
>
>
>
> template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
>
> template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
>
> template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
> const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
># 114 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> struct complex
> {
>
> typedef _Tp value_type;
>
>
>
> complex(const _Tp& = _Tp(), const _Tp & = _Tp());
>
>
>
>
> template<typename _Up>
> complex(const complex<_Up>&);
>
>
> _Tp& real();
>
> const _Tp& real() const;
>
> _Tp& imag();
>
> const _Tp& imag() const;
>
>
> complex<_Tp>& operator=(const _Tp&);
>
> complex<_Tp>& operator+=(const _Tp&);
>
> complex<_Tp>& operator-=(const _Tp&);
>
> complex<_Tp>& operator*=(const _Tp&);
>
> complex<_Tp>& operator/=(const _Tp&);
>
>
>
>
>
> template<typename _Up>
> complex<_Tp>& operator=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator+=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator-=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator*=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator/=(const complex<_Up>&);
>
> const complex& __rep() const;
>
> private:
> _Tp _M_real;
> _Tp _M_imag;
> };
>
> template<typename _Tp>
> inline _Tp&
> complex<_Tp>::real() { return _M_real; }
>
> template<typename _Tp>
> inline const _Tp&
> complex<_Tp>::real() const { return _M_real; }
>
> template<typename _Tp>
> inline _Tp&
> complex<_Tp>::imag() { return _M_imag; }
>
> template<typename _Tp>
> inline const _Tp&
> complex<_Tp>::imag() const { return _M_imag; }
>
> template<typename _Tp>
> inline
> complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
> : _M_real(__r), _M_imag(__i) { }
>
> template<typename _Tp>
> template<typename _Up>
> inline
> complex<_Tp>::complex(const complex<_Up>& __z)
> : _M_real(__z.real()), _M_imag(__z.imag()) { }
>
> template<typename _Tp>
> complex<_Tp>&
> complex<_Tp>::operator=(const _Tp& __t)
> {
> _M_real = __t;
> _M_imag = _Tp();
> return *this;
> }
>
>
> template<typename _Tp>
> inline complex<_Tp>&
> complex<_Tp>::operator+=(const _Tp& __t)
> {
> _M_real += __t;
> return *this;
> }
>
>
> template<typename _Tp>
> inline complex<_Tp>&
> complex<_Tp>::operator-=(const _Tp& __t)
> {
> _M_real -= __t;
> return *this;
> }
>
>
> template<typename _Tp>
> complex<_Tp>&
> complex<_Tp>::operator*=(const _Tp& __t)
> {
> _M_real *= __t;
> _M_imag *= __t;
> return *this;
> }
>
>
> template<typename _Tp>
> complex<_Tp>&
> complex<_Tp>::operator/=(const _Tp& __t)
> {
> _M_real /= __t;
> _M_imag /= __t;
> return *this;
> }
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator=(const complex<_Up>& __z)
> {
> _M_real = __z.real();
> _M_imag = __z.imag();
> return *this;
> }
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator+=(const complex<_Up>& __z)
> {
> _M_real += __z.real();
> _M_imag += __z.imag();
> return *this;
> }
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator-=(const complex<_Up>& __z)
> {
> _M_real -= __z.real();
> _M_imag -= __z.imag();
> return *this;
> }
>
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator*=(const complex<_Up>& __z)
> {
> const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
> _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
> _M_real = __r;
> return *this;
> }
>
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator/=(const complex<_Up>& __z)
> {
> const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
> const _Tp __n = std::norm(__z);
> _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
> _M_real = __r / __n;
> return *this;
> }
>
> template<typename _Tp>
> inline const complex<_Tp>&
> complex<_Tp>::__rep() const { return *this; }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r += __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r.real() += __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __y;
> __r.real() += __x;
> return __r;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r -= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r.real() -= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r(__x, -__y.imag());
> __r.real() -= __y.real();
> return __r;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r *= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator*(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r *= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator*(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __y;
> __r *= __x;
> return __r;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r /= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator/(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r /= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator/(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r /= __y;
> return __r;
> }
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const complex<_Tp>& __x)
> { return __x; }
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const complex<_Tp>& __x)
> { return complex<_Tp>(-__x.real(), -__x.imag()); }
>
>
>
> template<typename _Tp>
> inline bool
> operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
>
> template<typename _Tp>
> inline bool
> operator==(const complex<_Tp>& __x, const _Tp& __y)
> { return __x.real() == __y && __x.imag() == _Tp(); }
>
> template<typename _Tp>
> inline bool
> operator==(const _Tp& __x, const complex<_Tp>& __y)
> { return __x == __y.real() && _Tp() == __y.imag(); }
>
>
>
>
> template<typename _Tp>
> inline bool
> operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
>
> template<typename _Tp>
> inline bool
> operator!=(const complex<_Tp>& __x, const _Tp& __y)
> { return __x.real() != __y || __x.imag() != _Tp(); }
>
> template<typename _Tp>
> inline bool
> operator!=(const _Tp& __x, const complex<_Tp>& __y)
> { return __x != __y.real() || _Tp() != __y.imag(); }
>
>
>
> template<typename _Tp, typename _CharT, class _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
> {
> _Tp __re_x, __im_x;
> _CharT __ch;
> __is >> __ch;
> if (__ch == '(')
> {
> __is >> __re_x >> __ch;
> if (__ch == ',')
> {
> __is >> __im_x >> __ch;
> if (__ch == ')')
> __x = complex<_Tp>(__re_x, __im_x);
> else
> __is.setstate(ios_base::failbit);
> }
> else if (__ch == ')')
> __x = __re_x;
> else
> __is.setstate(ios_base::failbit);
> }
> else
> {
> __is.putback(__ch);
> __is >> __re_x;
> __x = __re_x;
> }
> return __is;
> }
>
>
> template<typename _Tp, typename _CharT, class _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
> {
> basic_ostringstream<_CharT, _Traits> __s;
> __s.flags(__os.flags());
> __s.imbue(__os.getloc());
> __s.precision(__os.precision());
> __s << '(' << __x.real() << ',' << __x.imag() << ')';
> return __os << __s.str();
> }
>
>
> template<typename _Tp>
> inline _Tp&
> real(complex<_Tp>& __z)
> { return __z.real(); }
>
> template<typename _Tp>
> inline const _Tp&
> real(const complex<_Tp>& __z)
> { return __z.real(); }
>
> template<typename _Tp>
> inline _Tp&
> imag(complex<_Tp>& __z)
> { return __z.imag(); }
>
> template<typename _Tp>
> inline const _Tp&
> imag(const complex<_Tp>& __z)
> { return __z.imag(); }
>
>
> template<typename _Tp>
> inline _Tp
> __complex_abs(const complex<_Tp>& __z)
> {
> _Tp __x = __z.real();
> _Tp __y = __z.imag();
> const _Tp __s = std::max(abs(__x), abs(__y));
> if (__s == _Tp())
> return __s;
> __x /= __s;
> __y /= __s;
> return __s * sqrt(__x * __x + __y * __y);
> }
>
>
> inline float
> __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
>
> inline double
> __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
>
> inline long double
> __complex_abs(const __complex__ long double& __z)
> { return __builtin_cabsl(__z); }
>
> template<typename _Tp>
> inline _Tp
> abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
># 586 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> inline _Tp
> __complex_arg(const complex<_Tp>& __z)
> { return atan2(__z.imag(), __z.real()); }
>
>
> inline float
> __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
>
> inline double
> __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
>
> inline long double
> __complex_arg(const __complex__ long double& __z)
> { return __builtin_cargl(__z); }
>
> template<typename _Tp>
> inline _Tp
> arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
># 616 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<bool>
> struct _Norm_helper
> {
> template<typename _Tp>
> static inline _Tp _S_do_it(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return __x * __x + __y * __y;
> }
> };
>
> template<>
> struct _Norm_helper<true>
> {
> template<typename _Tp>
> static inline _Tp _S_do_it(const complex<_Tp>& __z)
> {
> _Tp __res = std::abs(__z);
> return __res * __res;
> }
> };
>
> template<typename _Tp>
> inline _Tp
> norm(const complex<_Tp>& __z)
> {
> return _Norm_helper<__is_floating<_Tp>::__value
> && !0>::_S_do_it(__z);
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> polar(const _Tp& __rho, const _Tp& __theta)
> { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
>
> template<typename _Tp>
> inline complex<_Tp>
> conj(const complex<_Tp>& __z)
> { return complex<_Tp>(__z.real(), -__z.imag()); }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_cos(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
> }
>
>
> inline __complex__ float
> __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
>
> inline __complex__ double
> __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
>
> inline __complex__ long double
> __complex_cos(const __complex__ long double& __z)
> { return __builtin_ccosl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_cosh(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
> }
>
>
> inline __complex__ float
> __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
>
> inline __complex__ double
> __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
>
> inline __complex__ long double
> __complex_cosh(const __complex__ long double& __z)
> { return __builtin_ccoshl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_exp(const complex<_Tp>& __z)
> { return std::polar(exp(__z.real()), __z.imag()); }
>
>
> inline __complex__ float
> __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
>
> inline __complex__ double
> __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
>
> inline __complex__ long double
> __complex_exp(const __complex__ long double& __z)
> { return __builtin_cexpl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
># 747 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> __complex_log(const complex<_Tp>& __z)
> { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
>
>
> inline __complex__ float
> __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
>
> inline __complex__ double
> __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
>
> inline __complex__ long double
> __complex_log(const __complex__ long double& __z)
> { return __builtin_clogl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> log10(const complex<_Tp>& __z)
> { return std::log(__z) / log(_Tp(10.0)); }
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_sin(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
> }
>
>
> inline __complex__ float
> __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
>
> inline __complex__ double
> __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
>
> inline __complex__ long double
> __complex_sin(const __complex__ long double& __z)
> { return __builtin_csinl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_sinh(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
> }
>
>
> inline __complex__ float
> __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
>
> inline __complex__ double
> __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
>
> inline __complex__ long double
> __complex_sinh(const __complex__ long double& __z)
> { return __builtin_csinhl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
># 839 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> complex<_Tp>
> __complex_sqrt(const complex<_Tp>& __z)
> {
> _Tp __x = __z.real();
> _Tp __y = __z.imag();
>
> if (__x == _Tp())
> {
> _Tp __t = sqrt(abs(__y) / 2);
> return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
> }
> else
> {
> _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
> _Tp __u = __t / 2;
> return __x > _Tp()
> ? complex<_Tp>(__u, __y / __t)
> : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
> }
> }
>
>
> inline __complex__ float
> __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
>
> inline __complex__ double
> __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
>
> inline __complex__ long double
> __complex_sqrt(const __complex__ long double& __z)
> { return __builtin_csqrtl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
># 883 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> __complex_tan(const complex<_Tp>& __z)
> { return std::sin(__z) / std::cos(__z); }
>
>
> inline __complex__ float
> __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
>
> inline __complex__ double
> __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
>
> inline __complex__ long double
> __complex_tan(const __complex__ long double& __z)
> { return __builtin_ctanl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
># 911 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> __complex_tanh(const complex<_Tp>& __z)
> { return std::sinh(__z) / std::cosh(__z); }
>
>
> inline __complex__ float
> __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
>
> inline __complex__ double
> __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
>
> inline __complex__ long double
> __complex_tanh(const __complex__ long double& __z)
> { return __builtin_ctanhl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
># 940 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> pow(const complex<_Tp>& __z, int __n)
> { return std::__pow_helper(__z, __n); }
>
> template<typename _Tp>
> complex<_Tp>
> pow(const complex<_Tp>& __x, const _Tp& __y)
> {
>
>
>
>
> if (__x.imag() == _Tp() && __x.real() > _Tp())
> return pow(__x.real(), __y);
>
> complex<_Tp> __t = std::log(__x);
> return std::polar(exp(__y * __t.real()), __y * __t.imag());
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
>
>
> inline __complex__ float
> __complex_pow(__complex__ float __x, __complex__ float __y)
> { return __builtin_cpowf(__x, __y); }
>
> inline __complex__ double
> __complex_pow(__complex__ double __x, __complex__ double __y)
> { return __builtin_cpow(__x, __y); }
>
> inline __complex__ long double
> __complex_pow(const __complex__ long double& __x,
> const __complex__ long double& __y)
> { return __builtin_cpowl(__x, __y); }
>
> template<typename _Tp>
> inline complex<_Tp>
> pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __complex_pow(__x.__rep(), __y.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> pow(const _Tp& __x, const complex<_Tp>& __y)
> {
> return __x > _Tp() ? std::polar(pow(__x, __y.real()),
> __y.imag() * log(__x))
> : std::pow(complex<_Tp>(__x, _Tp()), __y);
> }
>
>
>
> template<>
> struct complex<float>
> {
> typedef float value_type;
> typedef __complex__ float _ComplexT;
>
> complex(_ComplexT __z) : _M_value(__z) { }
>
> complex(float = 0.0f, float = 0.0f);
>
> explicit complex(const complex<double>&);
> explicit complex(const complex<long double>&);
>
> float& real();
> const float& real() const;
> float& imag();
> const float& imag() const;
>
> complex<float>& operator=(float);
> complex<float>& operator+=(float);
> complex<float>& operator-=(float);
> complex<float>& operator*=(float);
> complex<float>& operator/=(float);
>
>
>
>
> template<typename _Tp>
> complex<float>&operator=(const complex<_Tp>&);
> template<typename _Tp>
> complex<float>& operator+=(const complex<_Tp>&);
> template<class _Tp>
> complex<float>& operator-=(const complex<_Tp>&);
> template<class _Tp>
> complex<float>& operator*=(const complex<_Tp>&);
> template<class _Tp>
> complex<float>&operator/=(const complex<_Tp>&);
>
> const _ComplexT& __rep() const { return _M_value; }
>
> private:
> _ComplexT _M_value;
> };
>
> inline float&
> complex<float>::real()
> { return __real__ _M_value; }
>
> inline const float&
> complex<float>::real() const
> { return __real__ _M_value; }
>
> inline float&
> complex<float>::imag()
> { return __imag__ _M_value; }
>
> inline const float&
> complex<float>::imag() const
> { return __imag__ _M_value; }
>
> inline
> complex<float>::complex(float r, float i)
> {
> __real__ _M_value = r;
> __imag__ _M_value = i;
> }
>
> inline complex<float>&
> complex<float>::operator=(float __f)
> {
> __real__ _M_value = __f;
> __imag__ _M_value = 0.0f;
> return *this;
> }
>
> inline complex<float>&
> complex<float>::operator+=(float __f)
> {
> __real__ _M_value += __f;
> return *this;
> }
>
> inline complex<float>&
> complex<float>::operator-=(float __f)
> {
> __real__ _M_value -= __f;
> return *this;
> }
>
> inline complex<float>&
> complex<float>::operator*=(float __f)
> {
> _M_value *= __f;
> return *this;
> }
>
> inline complex<float>&
> complex<float>::operator/=(float __f)
> {
> _M_value /= __f;
> return *this;
> }
>
> template<typename _Tp>
> inline complex<float>&
> complex<float>::operator=(const complex<_Tp>& __z)
> {
> __real__ _M_value = __z.real();
> __imag__ _M_value = __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<float>&
> complex<float>::operator+=(const complex<_Tp>& __z)
> {
> __real__ _M_value += __z.real();
> __imag__ _M_value += __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<float>&
> complex<float>::operator-=(const complex<_Tp>& __z)
> {
> __real__ _M_value -= __z.real();
> __imag__ _M_value -= __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<float>&
> complex<float>::operator*=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value *= __t;
> return *this;
> }
>
> template<typename _Tp>
> inline complex<float>&
> complex<float>::operator/=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value /= __t;
> return *this;
> }
>
>
>
> template<>
> struct complex<double>
> {
> typedef double value_type;
> typedef __complex__ double _ComplexT;
>
> complex(_ComplexT __z) : _M_value(__z) { }
>
> complex(double = 0.0, double = 0.0);
>
> complex(const complex<float>&);
> explicit complex(const complex<long double>&);
>
> double& real();
> const double& real() const;
> double& imag();
> const double& imag() const;
>
> complex<double>& operator=(double);
> complex<double>& operator+=(double);
> complex<double>& operator-=(double);
> complex<double>& operator*=(double);
> complex<double>& operator/=(double);
>
>
>
> template<typename _Tp>
> complex<double>& operator=(const complex<_Tp>&);
> template<typename _Tp>
> complex<double>& operator+=(const complex<_Tp>&);
> template<typename _Tp>
> complex<double>& operator-=(const complex<_Tp>&);
> template<typename _Tp>
> complex<double>& operator*=(const complex<_Tp>&);
> template<typename _Tp>
> complex<double>& operator/=(const complex<_Tp>&);
>
> const _ComplexT& __rep() const { return _M_value; }
>
> private:
> _ComplexT _M_value;
> };
>
> inline double&
> complex<double>::real()
> { return __real__ _M_value; }
>
> inline const double&
> complex<double>::real() const
> { return __real__ _M_value; }
>
> inline double&
> complex<double>::imag()
> { return __imag__ _M_value; }
>
> inline const double&
> complex<double>::imag() const
> { return __imag__ _M_value; }
>
> inline
> complex<double>::complex(double __r, double __i)
> {
> __real__ _M_value = __r;
> __imag__ _M_value = __i;
> }
>
> inline complex<double>&
> complex<double>::operator=(double __d)
> {
> __real__ _M_value = __d;
> __imag__ _M_value = 0.0;
> return *this;
> }
>
> inline complex<double>&
> complex<double>::operator+=(double __d)
> {
> __real__ _M_value += __d;
> return *this;
> }
>
> inline complex<double>&
> complex<double>::operator-=(double __d)
> {
> __real__ _M_value -= __d;
> return *this;
> }
>
> inline complex<double>&
> complex<double>::operator*=(double __d)
> {
> _M_value *= __d;
> return *this;
> }
>
> inline complex<double>&
> complex<double>::operator/=(double __d)
> {
> _M_value /= __d;
> return *this;
> }
>
> template<typename _Tp>
> inline complex<double>&
> complex<double>::operator=(const complex<_Tp>& __z)
> {
> __real__ _M_value = __z.real();
> __imag__ _M_value = __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<double>&
> complex<double>::operator+=(const complex<_Tp>& __z)
> {
> __real__ _M_value += __z.real();
> __imag__ _M_value += __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<double>&
> complex<double>::operator-=(const complex<_Tp>& __z)
> {
> __real__ _M_value -= __z.real();
> __imag__ _M_value -= __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<double>&
> complex<double>::operator*=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value *= __t;
> return *this;
> }
>
> template<typename _Tp>
> inline complex<double>&
> complex<double>::operator/=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value /= __t;
> return *this;
> }
>
>
>
> template<>
> struct complex<long double>
> {
> typedef long double value_type;
> typedef __complex__ long double _ComplexT;
>
> complex(_ComplexT __z) : _M_value(__z) { }
>
> complex(long double = 0.0L, long double = 0.0L);
>
> complex(const complex<float>&);
> complex(const complex<double>&);
>
> long double& real();
> const long double& real() const;
> long double& imag();
> const long double& imag() const;
>
> complex<long double>& operator= (long double);
> complex<long double>& operator+= (long double);
> complex<long double>& operator-= (long double);
> complex<long double>& operator*= (long double);
> complex<long double>& operator/= (long double);
>
>
>
> template<typename _Tp>
> complex<long double>& operator=(const complex<_Tp>&);
> template<typename _Tp>
> complex<long double>& operator+=(const complex<_Tp>&);
> template<typename _Tp>
> complex<long double>& operator-=(const complex<_Tp>&);
> template<typename _Tp>
> complex<long double>& operator*=(const complex<_Tp>&);
> template<typename _Tp>
> complex<long double>& operator/=(const complex<_Tp>&);
>
> const _ComplexT& __rep() const { return _M_value; }
>
> private:
> _ComplexT _M_value;
> };
>
> inline
> complex<long double>::complex(long double __r, long double __i)
> {
> __real__ _M_value = __r;
> __imag__ _M_value = __i;
> }
>
> inline long double&
> complex<long double>::real()
> { return __real__ _M_value; }
>
> inline const long double&
> complex<long double>::real() const
> { return __real__ _M_value; }
>
> inline long double&
> complex<long double>::imag()
> { return __imag__ _M_value; }
>
> inline const long double&
> complex<long double>::imag() const
> { return __imag__ _M_value; }
>
> inline complex<long double>&
> complex<long double>::operator=(long double __r)
> {
> __real__ _M_value = __r;
> __imag__ _M_value = 0.0L;
> return *this;
> }
>
> inline complex<long double>&
> complex<long double>::operator+=(long double __r)
> {
> __real__ _M_value += __r;
> return *this;
> }
>
> inline complex<long double>&
> complex<long double>::operator-=(long double __r)
> {
> __real__ _M_value -= __r;
> return *this;
> }
>
> inline complex<long double>&
> complex<long double>::operator*=(long double __r)
> {
> _M_value *= __r;
> return *this;
> }
>
> inline complex<long double>&
> complex<long double>::operator/=(long double __r)
> {
> _M_value /= __r;
> return *this;
> }
>
> template<typename _Tp>
> inline complex<long double>&
> complex<long double>::operator=(const complex<_Tp>& __z)
> {
> __real__ _M_value = __z.real();
> __imag__ _M_value = __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<long double>&
> complex<long double>::operator+=(const complex<_Tp>& __z)
> {
> __real__ _M_value += __z.real();
> __imag__ _M_value += __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<long double>&
> complex<long double>::operator-=(const complex<_Tp>& __z)
> {
> __real__ _M_value -= __z.real();
> __imag__ _M_value -= __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> inline complex<long double>&
> complex<long double>::operator*=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value *= __t;
> return *this;
> }
>
> template<typename _Tp>
> inline complex<long double>&
> complex<long double>::operator/=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value /= __t;
> return *this;
> }
>
>
>
>
>
> inline
> complex<float>::complex(const complex<double>& __z)
> : _M_value(__z.__rep()) { }
>
> inline
> complex<float>::complex(const complex<long double>& __z)
> : _M_value(__z.__rep()) { }
>
> inline
> complex<double>::complex(const complex<float>& __z)
> : _M_value(__z.__rep()) { }
>
> inline
> complex<double>::complex(const complex<long double>& __z)
> : _M_value(__z.__rep()) { }
>
> inline
> complex<long double>::complex(const complex<float>& __z)
> : _M_value(__z.__rep()) { }
>
> inline
> complex<long double>::complex(const complex<double>& __z)
> : _M_value(__z.__rep()) { }
>}
># 2 "/usr/local/include/mtl/mtl_complex.h" 2 3
># 5 "/usr/local/include/mtl/matrix_traits.h" 2 3
># 1 "/usr/local/include/mtl/mtl_config.h" 1 3
># 6 "/usr/local/include/mtl/matrix_traits.h" 2 3
>
>namespace mtl {
>
> enum { RECT, BAND, TRI, SYMM, HERM, ROW_MAJOR, COL_MAJOR, DIAG, DENSE,
> PACKED, BAND_VIEW, SPARSE, ARRAY, ENVELOPE,
> COMPRESSED, SPARSE_PAIR, TREE, LINKED_LIST,
> upper, lower, unit_upper, unit_lower, dynamic_uplo,
> internal = 0, external,
> index_from_one = -1, index_from_zero = 0 };
>
>
>
>
>
>template <class Matrix>
>struct matrix_traits {
>
>
> typedef typename Matrix::shape shape;
>
> typedef typename Matrix::orientation orientation;
>
> typedef typename Matrix::sparsity sparsity;
>
>
> typedef typename Matrix::transpose_type transpose_type;
>
> typedef typename Matrix::strided_type strided_type;
>
> typedef typename Matrix::strideability strideability;
>
> typedef typename Matrix::scaled_type scaled_type;
>
> typedef typename Matrix::storage_loc storage_loc;
>
>
> typedef typename Matrix::OneD OneD;
>
>
> typedef typename Matrix::value_type value_type;
> typedef typename Matrix::reference reference;
> typedef typename Matrix::const_reference const_reference;
> typedef typename Matrix::pointer pointer;
>
>
> typedef typename Matrix::size_type size_type;
> typedef typename Matrix::difference_type difference_type;
>
>};
>
>
>
>template <class Matrix>
>struct row_matrix_traits {
> typedef typename Matrix::Row Row;
>};
>
>
>
>
>template <class Matrix>
>struct column_matrix_traits {
> typedef typename Matrix::Column Column;
>};
>
>
>
>
>template <class Matrix>
>struct diagonal_matrix_traits {
> typedef typename Matrix::Diagonal Diagonal;
>};
># 86 "/usr/local/include/mtl/matrix_traits.h" 3
>class rectangle_tag { public: enum{ id = RECT}; };
>
>
>
>
>class banded_tag { public: enum{ id = BAND};};
>
>
>
>
>class triangle_tag : public banded_tag { public: enum{id = TRI};};
>
>
>
>
>class symmetric_tag : public banded_tag { public: enum{id=SYMM};};
>
>
>
>
>class hermitian_tag : public banded_tag{ public: enum{id=HERM};};
>
>
>
>
>class diagonal_tag : public banded_tag { public: enum{id=DIAG};};
># 120 "/usr/local/include/mtl/matrix_traits.h" 3
>class external_tag { };
>
>
>
>
>class internal_tag { };
># 134 "/usr/local/include/mtl/matrix_traits.h" 3
>struct row_tag { enum { id = ROW_MAJOR }; };
>
>
>
>
>struct column_tag { enum { id = COL_MAJOR }; };
># 148 "/usr/local/include/mtl/matrix_traits.h" 3
>struct dense_tag { enum { id = DENSE }; };
>
>
>
>
>struct sparse_tag { enum { id = SPARSE }; };
># 162 "/usr/local/include/mtl/matrix_traits.h" 3
>struct oned_tag { };
>
>
>
>
>struct twod_tag { };
>
>
>template <class number_type>
>struct number_traits {
> typedef number_type magnitude_type;
>};
>
>
>template <class T>
>struct number_traits< std::complex<T> > {
> typedef T magnitude_type;
>};
># 193 "/usr/local/include/mtl/matrix_traits.h" 3
>template <class Linalg>
>struct linalg_traits {
>
>
> typedef typename Linalg::dimension dimension;
>
> typedef typename Linalg::value_type value_type;
>
> typedef typename Linalg::sparsity sparsity;
>
> typedef typename number_traits<value_type>::magnitude_type magnitude_type;
>};
>
>
>
>
>struct strideable { };
>
>
>
>
>struct not_strideable { };
>
>
>
>
>
>
>struct do_transpose { };
>
>
>
>struct do_strided { };
>
>
>
>struct do_scaled { };
>
>
>
>struct do_stream { };
>
>}
># 12 "/usr/local/include/mtl/mtl_decl.h" 2 3
># 25 "/usr/local/include/mtl/mtl_decl.h" 3
>namespace mtl {
>
>template <class Vec>
>inline typename Vec::size_type
>max_index(const Vec& x);
>
>template <class Vec>
>inline typename Vec::size_type
>max_abs_index(const Vec& x);
>
>template<class Vec>
>inline typename Vec::size_type
>min_index(const Vec& x);
>
>template<class Vec>
>inline typename Vec::size_type
>min_abs_index(const Vec& x);
>
>template <class VectorT>
>inline typename VectorT::value_type
>max(const VectorT& x);
>
>template <class VectorT>
>inline typename VectorT::value_type
>min(const VectorT& x);
>
>template <class Matrix>
>inline void
>transpose(const Matrix& A_);
>
>template <class MatA, class MatB>
>inline void
>transpose(const MatA& A, const MatB& B_);
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>rect_mult(const Matrix& A, const VecX& xx, VecZ& zz,
> row_tag, dense_tag);
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>rect_mult(const Matrix& A, const VecX& xx, VecZ& zz,
> column_tag, dense_tag);
>
>template <class Matrix, class VecX, class VecY>
>void
>rect_mult(const Matrix& A, const VecX& x, VecY& y,
> column_tag, sparse_tag);
>
>template <class Matrix, class VecX, class VecY>
>void
>rect_mult(const Matrix& A, const VecX& x, VecY& y,
> row_tag, sparse_tag);
>
>template <class Matrix, class VecX, class VecY, class VecZ>
>inline void
>mult(const Matrix& A, const VecX& x, const VecY& y, const VecZ& z_);
>
>template <class Matrix, class VecX, class VecY>
>inline void
>mult_add(const Matrix& A, const VecX& x, const VecY& y_);
>
>template <class MatA, class MatB, class MatC, class Orien>
>inline void
>simple_mult(const MatA& A, const MatB& B, MatC& C, dense_tag, Orien);
>
>template <class MatrixA, class MatrixB, class MatrixC>
>inline void
>simple_mult(const MatrixA& A, const MatrixB& B, MatrixC& C,
> sparse_tag, row_tag);
>
>
>template <class MatrixA, class MatrixB, class MatrixC>
>inline void
>simple_mult(const MatrixA& A, const MatrixB& B, MatrixC& C,
> sparse_tag, column_tag);
>
>template <class MatA, class MatB, class MatC>
>inline void
>symm_simple_mult(const MatA& A, const MatB& B, MatC& C, row_tag);
>
>template <class MatA, class MatB, class MatC>
>inline void
>symm_simple_mult(const MatA& A, const MatB& B, MatC& C, column_tag);
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, symmetric_tag);
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, triangle_tag);
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, rectangle_tag);
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, banded_tag);
>
>template <class LinalgA, class LinalgB, class LinalgC>
>inline void
>mult(const LinalgA& A, const LinalgB& B, const LinalgC& C_);
>
>template <class TriMatrix, class VecX>
>inline void
>tri_solve(const TriMatrix& T, const VecX& x_);
>
>template <class MatT, class MatB, class Side>
>inline void
>tri_solve(const MatT& T, const MatB& B, Side s);
>
>template <class Matrix, class VecX, class VecY>
>inline void
>rank_one_update(const Matrix& A_,
> const VecX& x, const VecY& y);
>
>template <class Matrix, class VecX, class VecY>
>inline void
>rank_two_update(const Matrix& A_,
> const VecX& x, const VecY& y);
>
>template <class VecX, class VecY>
>inline void
>oned_copy(const VecX& x, VecY& y, dense_tag, dense_tag);
>
>template <class VecX, class VecY, class Tag>
>inline void
>oned_copy(const VecX& x, VecY& y, Tag, sparse_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, rectangle_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, banded_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, symmetric_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, triangle_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, row_tag, row_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, column_tag, column_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, row_tag, column_tag);
>
>template <class LinalgA, class LinalgB>
>inline void
>copy(const LinalgA& A, const LinalgB& B_);
>
>template <class VecX, class VecY, class VecZ>
>inline void
>oned_add(const VecX& x, const VecY& y, VecZ& z_, sparse_tag);
>
>template <class VecX, class VecY, class VecZ>
>inline void
>oned_add(const VecX& x, const VecY& y, VecZ& z, dense_tag);
>
>template <class VecX, class VecY, class VecZ>
>inline void
>add(const VecX& x, const VecY& y, const VecZ& z_);
>
>template <class VecW, class VecX, class VecY, class VecZ>
>inline void
>add(const VecX& x, const VecY& y, const VecZ& z, const VecW& w_);
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, banded_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, rectangle_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, triangle_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_symmetric_add(const MatA& A, MatB& B, row_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_symmetric_add(const MatA& A, MatB& B, column_tag);
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, symmetric_tag);
>
>template <class LinalgA, class LinalgB>
>inline void
>add(const LinalgA& A, const LinalgB& B_);
>
>template <class VecX, class VecY, class VecZ>
>inline void
>ele_mult(const VecX& x, const VecY& y, const VecZ& z_);
>
>template <class MatA, class MatB>
>inline void
>ele_mult(const MatA& A, const MatB& B_);
>
>template <class VecX, class VecY, class VecZ>
>inline void
>ele_div(const VecX& x, const VecY& y, const VecZ& z_);
>
>template <class VecX, class VecY>
>inline void
>swap(VecX& x, VecY& y, oned_tag);
>
>template <class MatA, class MatB>
>inline void
>swap(MatA& A, MatB& B, twod_tag);
>
>template <class LinalgA, class LinalgB>
>inline void
>swap(const LinalgA& A, const LinalgB& B);
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, dense_tag, dense_tag);
>
>template <class InputIterator1, class InputIterator2, class T>
>inline T
>sparse_inner_product(InputIterator1 f1, InputIterator1 l1,
> InputIterator2 f2, InputIterator2 l2, T init);
>
>template <class IndexedIterator, class RandomAccessIterator, class T>
>inline T
>sparse_dense_inner_product(IndexedIterator f1, IndexedIterator l1,
> RandomAccessIterator f2, T init);
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, sparse_tag, sparse_tag);
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, dense_tag, sparse_tag);
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, sparse_tag, dense_tag);
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s);
>
>template <class VecX, class VecY>
>inline typename VecX::value_type
>dot(const VecX& x, const VecY& y);
>
>template <class VecX, class VecY, class T>
>inline T
>dot_conj(const VecX& x, const VecY& y, T s);
>
>}
># 18 "/usr/local/include/mtl/mtl.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/functional" 1 3
># 51 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/functional" 3
> 
># 52 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/functional" 3
># 20 "/usr/local/include/mtl/mtl.h" 2 3
>
># 1 "/usr/local/include/mtl/mtl_limits.h" 1 3
># 22 "/usr/local/include/mtl/mtl.h" 2 3
># 1 "/usr/local/include/mtl/mtl_complex.h" 1 3
># 23 "/usr/local/include/mtl/mtl.h" 2 3
>
># 1 "/usr/local/include/mtl/fast.h" 1 3
># 18 "/usr/local/include/mtl/fast.h" 3
># 1 "/usr/local/include/mtl/mtl_algo.h" 1 3
># 15 "/usr/local/include/mtl/mtl_algo.h" 3
># 1 "/usr/local/include/mtl/not_at.h" 1 3
># 15 "/usr/local/include/mtl/not_at.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iterator" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iterator" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iterator" 3
># 72 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iterator" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stream_iterator.h" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stream_iterator.h" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stream_iterator.h" 3
>
>
>
>namespace std
>{
>
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
> class istream_iterator
> : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
> {
> public:
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
> private:
> istream_type* _M_stream;
> _Tp _M_value;
> bool _M_ok;
>
> public:
>
> istream_iterator()
> : _M_stream(0), _M_value(), _M_ok(false) {}
>
>
> istream_iterator(istream_type& __s)
> : _M_stream(&__s)
> { _M_read(); }
>
> istream_iterator(const istream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
> _M_ok(__obj._M_ok)
> { }
>
> const _Tp&
> operator*() const
> {
> ;
>
>
> return _M_value;
> }
>
> const _Tp*
> operator->() const { return &(operator*()); }
>
> istream_iterator&
> operator++()
> {
> ;
>
>
> _M_read();
> return *this;
> }
>
> istream_iterator
> operator++(int)
> {
> ;
>
>
> istream_iterator __tmp = *this;
> _M_read();
> return __tmp;
> }
>
> bool
> _M_equal(const istream_iterator& __x) const
> { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
>
> private:
> void
> _M_read()
> {
> _M_ok = (_M_stream && *_M_stream) ? true : false;
> if (_M_ok)
> {
> *_M_stream >> _M_value;
> _M_ok = *_M_stream ? true : false;
> }
> }
> };
>
>
> template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
> inline bool
> operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return __x._M_equal(__y); }
>
>
> template <class _Tp, class _CharT, class _Traits, class _Dist>
> inline bool
> operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return !__x._M_equal(__y); }
># 150 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stream_iterator.h" 3
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT> >
> class 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* _M_stream;
> const _CharT* _M_string;
>
> public:
>
> ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
># 181 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stream_iterator.h" 3
> ostream_iterator(ostream_type& __s, const _CharT* __c)
> : _M_stream(&__s), _M_string(__c) { }
>
>
> ostream_iterator(const ostream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
>
>
>
> ostream_iterator&
> operator=(const _Tp& __value)
> {
> ;
>
>
> *_M_stream << __value;
> if (_M_string) *_M_stream << _M_string;
> return *this;
> }
>
> ostream_iterator&
> operator*()
> { return *this; }
>
> ostream_iterator&
> operator++()
> { return *this; }
>
> ostream_iterator&
> operator++(int)
> { return *this; }
> };
>}
># 73 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/iterator" 2 3
># 2 "/usr/local/include/mtl/mtl_iterator.h" 2 3
># 16 "/usr/local/include/mtl/not_at.h" 2 3
>
>
>
>
>namespace mtl {
>
>using std::random_access_iterator_tag;
>using std::input_iterator_tag;
>
>template <class Ran1, class Ran2>
>inline bool not_at(const Ran1& a, const Ran2& b, random_access_iterator_tag) {
> return a < b;
>}
>
>template <class Iter1, class Iter2>
>inline bool not_at(const Iter1& a, const Iter2& b, input_iterator_tag) {
> return a != b;
>}
>
>template <class Iter1, class Iter2>
>inline bool not_at(const Iter1& a, const Iter2& b) {
>
> typedef typename std::iterator_traits<Iter1>::iterator_category Category;
> return mtl::not_at(a, b, Category());
>
>
>
>}
>
>inline bool not_at(int a, int b) {
> return a < b;
>}
>
>}
># 16 "/usr/local/include/mtl/mtl_algo.h" 2 3
>
># 1 "/usr/local/include/mtl/fast.h" 1 3
># 18 "/usr/local/include/mtl/mtl_algo.h" 2 3
>
>namespace mtl_algo {
>
>
>
>
>template <class InputIterator, class OutputIterator>
>inline OutputIterator
>copy(InputIterator f, InputIterator l, OutputIterator r)
>{
> InputIterator first = f;
> InputIterator last = l;
> OutputIterator result = r;
>
> while (mtl::not_at(first, last))
> *result++ = *first++;
> return result;
>}
>
>
>
>template <class BidirectionalIterator1, class BidirectionalIterator2>
>inline BidirectionalIterator2
>copy_backward(BidirectionalIterator1 first,
> BidirectionalIterator1 last,
> BidirectionalIterator2 result)
>{
> while (mtl::not_at(first, last))
> *--result = *--last;
> return result;
>}
>
>
>
>template <class T>
>inline void
>swap(T& a, T& b)
>{
> T tmp = a;
> a = b;
> b = tmp;
>}
>
>
>
>template <class ForwardIterator1, class ForwardIterator2, class T>
>inline void
>__iter_swap(ForwardIterator1 a, ForwardIterator2 b, T*)
>{
> T tmp = *a;
> *a = *b;
> *b = tmp;
>}
>
>template <class ForwardIterator1, class ForwardIterator2>
>inline void
>iter_swap(ForwardIterator1 a, ForwardIterator2 b)
>{
> typedef typename std::iterator_traits <ForwardIterator1>::value_type
> Value;
> mtl_algo::__iter_swap(a, b, (Value*)0);
>}
>
>
>
>template <class ForwardIterator, class T>
>inline void
>fill(ForwardIterator first, ForwardIterator last, const T& value)
>{
> while (mtl::not_at(first, last))
> *first++ = value;
>}
>
>template <class OutputIterator, class Size, class T>
>inline OutputIterator
>fill_n(OutputIterator first, Size n, const T& value)
>{
> while (n-- > 0)
> *first++ = value;
> return first;
>}
>
>
>
>
>template <class ForwardIterator1, class ForwardIterator2>
>inline ForwardIterator2
>swap_ranges(ForwardIterator1 f1, ForwardIterator1 l1,
> ForwardIterator2 f2)
>{
> ForwardIterator1 first1 = f1;
> ForwardIterator1 last1 = l1;
> ForwardIterator2 first2 = f2;
>
> while (mtl::not_at(first1, last1))
> mtl_algo::swap(*first1++, *first2++);
>
> return first2;
>}
>
>
>
>
>
>
>template <class InputIterator, class T>
>inline T
>accumulate(InputIterator f, InputIterator l, T init)
>{
> InputIterator first = f;
> InputIterator last = l;
>
> while (mtl::not_at(first, last))
> init = init + *first++;
>
> return init;
>}
>
>template <class InputIterator, class T, class BinaryOperation>
>inline T
>accumulate(InputIterator f, InputIterator l, T init,
> BinaryOperation binary_op)
>{
> InputIterator first = f;
> InputIterator last = l;
>
> while (mtl::not_at(first, last)) {
> init = binary_op (init, *first++);
> }
> return init;
>}
>
>
>
>template <class InputIterator1, class InputIterator2, class T>
>inline T
>inner_product(InputIterator1 f1, InputIterator1 l1,
> InputIterator2 f2, T init)
>{
> InputIterator1 first1 = f1;
> InputIterator1 last1 = l1;
> InputIterator2 first2 = f2;
>
> while (mtl::not_at(first1, last1))
> init += (*first1++ * *first2++);
>
> return init;
>}
>
>template <class InputIterator1, class InputIterator2, class T,
> class BinaryOperation1, class BinaryOperation2>
>inline T
>inner_product(InputIterator1 f1, InputIterator1 l1,
> InputIterator2 f2, T init,
> BinaryOperation1 binary_op1,
> BinaryOperation2 binary_op2)
>{
> InputIterator1 first1 = f1;
> InputIterator1 last1 = l1;
> InputIterator2 first2 = f2;
>
> while (mtl::not_at(first1, last1))
> init = binary_op1 (init, binary_op2 (*first1++, *first2++));
>
> return init;
>}
>
>
>
>template <class InputIterator, class OutputIterator>
>OutputIterator
>partial_sum(InputIterator first, InputIterator last,
> OutputIterator result)
>{
> typedef typename std::iterator_traits<InputIterator>::value_type sum_type;
> if( mtl::not_at(first, last) ) {
> sum_type sum1( *first );
> for(;;) {
> *result = sum1;
> ++result;
> if( ++first==last ) break;
> sum_type sum2( sum1 + *first );
> *result = sum2;
> ++result;
> if( ++first==last ) break;
> sum1.~sum_type();
> new((void*)&sum1) sum_type( sum2 + *first );
> }
> }
> return result;
>}
>
>template <class InputIterator, class OutputIterator, class BinaryOperation>
>OutputIterator
>partial_sum (InputIterator first, InputIterator last,
> OutputIterator result, BinaryOperation op)
>{
> typedef typename std::iterator_traits<InputIterator>::value_type sum_type;
> if( mtl::not_at(first, last) ) {
> sum_type sum1( *first );
> for(;;) {
> *result = sum1;
> ++result;
> if( ++first==last ) break;
> sum_type sum2( op( sum1, *first ) );
> *result = sum2;
> ++result;
> if( ++first==last ) break;
> sum1.~sum_type();
> new((void*)&sum1) sum_type( op( sum2, *first ) );
> }
> }
> return result;
>}
>
>
>
>template <class InputIterator, class OutputIterator>
>OutputIterator
>adjacent_difference(InputIterator first, InputIterator last,
> OutputIterator result)
>{
> typedef typename std::iterator_traits <InputIterator>::value_type
> value_type;
> if (mtl::not_at(first, last)) {
> value_type value0( *first );
> *result = value0;
> while( ++result, mtl::not_at(++first, last) ) {
> value_type value1(*first);
> *result = value1 - value0;
> value0.~value_type();
> new((void*)&value0) value_type( value1 );
> }
> }
> return result;
>}
>
>template <class InputIterator, class OutputIterator, class BinaryOperation>
>OutputIterator
>adjacent_difference(InputIterator first, InputIterator last,
> OutputIterator result,
> BinaryOperation binary_op)
>{
> typedef typename std::iterator_traits <InputIterator>::value_type
> value_type;
> if (mtl::not_at(first, last)) {
> value_type value0( *first );
> *result = value0;
> while( ++result, mtl::not_at(++first, last) ) {
> value_type value1(*first);
> *result = binary_op(value1,value0);
> value0.~value_type();
> new((void*)&value0) value_type( value1 );
> }
> }
> return result;
>}
>
>
>
>
>
>template <class InputIterator, class Function>
>inline Function
>for_each(InputIterator f, InputIterator l, Function func)
>{
> InputIterator first = f;
> InputIterator last = l;
>
> for( ; mtl::not_at(first, last); ++first)
> func(*first);
> return func;
>}
>
>
>
>
>template <class InputIterator, class OutputIterator, class UnaryOperation>
>inline
>OutputIterator
>transform(InputIterator f, InputIterator l,
> OutputIterator r, UnaryOperation op)
>{
> InputIterator first = f;
> InputIterator last = l;
> OutputIterator result = r;
>
> while (mtl::not_at(first, last))
> *result++ = op (*first++);
>
> return result;
>}
>
>template <class InputIterator, class OutputIterator>
>inline
>OutputIterator
>transform_add(InputIterator f, InputIterator l,
> OutputIterator r)
>{
> InputIterator first = f;
> InputIterator last = l;
> OutputIterator result = r;
>
> while (mtl::not_at(first, last)) {
> *result += *first++;
> ++result;
> }
> return result;
>}
># 364 "/usr/local/include/mtl/mtl_algo.h" 3
>template <class InputIterator1, class InputIterator2, class OutputIterator,
> class BinaryOperation, class Tag>
>inline
>OutputIterator
>__transform(InputIterator1 f1, InputIterator1 l1,
> InputIterator2 f2, OutputIterator r,
> BinaryOperation binary_op, Tag)
>{
> InputIterator1 first1 = f1;
> InputIterator1 last1 = l1;
> InputIterator2 first2 = f2;
> OutputIterator result = r;
>
> while (mtl::not_at(first1, last1)) {
> *result = binary_op (*first1, *first2);
> ++first1; ++first2; ++result;
> }
> return result;
>}
>
>template <class InputIterator1, class InputIterator2, class OutputIterator,
> class BinaryOperation>
>inline
>OutputIterator
>transform(InputIterator1 f1, InputIterator1 l1,
> InputIterator2 f2, OutputIterator r,
> BinaryOperation binary_op)
>{
> typedef typename std::iterator_traits<InputIterator1>::iterator_category Cat;
> return __transform(f1, l1, f2, r, binary_op, Cat());
>}
>
>
>template <class ForwardIterator>
>inline ForwardIterator
>max_element(ForwardIterator f, ForwardIterator l)
>{
> ForwardIterator first = f;
> ForwardIterator last = l;
>
> if (first == last) return first;
> ForwardIterator result = first;
>
> while (mtl::not_at(++first, last))
> if (*result < *first)
> result = first;
>
> return result;
>}
>
>template <class ForwardIterator, class Compare>
>inline ForwardIterator
>max_element(ForwardIterator f, ForwardIterator l,
> Compare comp)
>{
> ForwardIterator first = f;
> ForwardIterator last = l;
>
> if (first == last) return first;
> ForwardIterator result = first;
> while (mtl::not_at(++first, last)) {
> if (comp (*result, *first))
> result = first;
> }
> return result;
>}
>
>template <class ForwardIterator>
>inline ForwardIterator
>min_element(ForwardIterator f, ForwardIterator l)
>{
> ForwardIterator first = f;
> ForwardIterator last = l;
>
> if (first == last) return first;
> ForwardIterator result = first;
>
> while (mtl::not_at(++first, last))
> if (*first < *result)
> result = first;
>
> return result;
>}
>
>template <class ForwardIterator, class Compare>
>inline ForwardIterator
>min_element(ForwardIterator f, ForwardIterator l,
> Compare comp)
>{
> ForwardIterator first = f;
> ForwardIterator last = l;
>
> if (first == last) return first;
> ForwardIterator result = first;
>
> while (mtl::not_at(++first, last))
> if (comp (*first, *result))
> result = first;
>
> return result;
>}
>
>}
># 19 "/usr/local/include/mtl/fast.h" 2 3
>
>
>namespace fast {
># 31 "/usr/local/include/mtl/fast.h" 3
>template <int NN>
>struct count {
> enum { N = NN };
>};
>
>
>
>template <>
>struct count<0> {
> enum { N = 0 };
>};
># 50 "/usr/local/include/mtl/fast.h" 3
>template <int N, class InIter, class OutIter>
>inline OutIter
>copy(InIter first, count<N>, OutIter result)
>{
> *result = *first;
> return copy(++first, count<N-1>(), ++result);
>}
>
>template <class InIter, class OutIter>
>inline OutIter
>copy(InIter first, count<0>, OutIter result)
>{
> return result;
>}
># 74 "/usr/local/include/mtl/fast.h" 3
>template <int N, class InIter, class OutIter, class UnaryOp>
>inline OutIter
>transform(InIter first, count<N>, OutIter result, UnaryOp op)
>{
> *result = op (*first);
> return transform(++first, count<N-1>(), ++result, op);
>}
>
>template <class InIter, class OutIter, class UnaryOp>
>inline OutIter
>transform(InIter first, count<0>, OutIter result, UnaryOp op)
>{
> return result;
>}
># 96 "/usr/local/include/mtl/fast.h" 3
>template <int N, class InIter1, class InIter2, class OutIter, class BinOp>
>inline OutIter
>transform (InIter1 first1, count<N>, InIter2 first2,
> OutIter result, BinOp binary_op)
>{
> *result = binary_op (*first1, *first2);
> return transform(++first1, count<N-1>(), ++first2, ++result, binary_op);
>}
>
>template <class InIter1, class InIter2, class OutIter, class BinaryOp>
>inline OutIter
>transform (InIter1 first1, count<0>, InIter2 first2,
> OutIter result, BinaryOp binary_op)
>{
> return result;
>}
>
>
>
>
>
>
>
>template <int N, class OutputIterator, class T>
>inline OutputIterator
>fill(OutputIterator first, count<N>, const T& value)
>{
> *first = value;
> return fill(++first, count<N-1>(), value);
>}
>template <class OutputIterator, class T>
>inline OutputIterator
>fill(OutputIterator first, count<0>, const T& value) { return first; }
># 137 "/usr/local/include/mtl/fast.h" 3
>template <int N, class ForwardIterator1, class ForwardIterator2>
>inline ForwardIterator2
>swap_ranges(ForwardIterator1 first1, count<N>, ForwardIterator2 first2)
>{
> mtl_algo::swap(*first1, *first2);
> return swap_ranges(++first1, count<N-1>(), ++first2);
>}
>
>template <class ForwardIterator1, class ForwardIterator2>
>inline ForwardIterator2
>swap_ranges(ForwardIterator1 first1, count<0>, ForwardIterator2 first2)
>{
> return first2;
>}
># 159 "/usr/local/include/mtl/fast.h" 3
>template <int N, class InputIterator, class T>
>inline T
>accumulate(InputIterator first, count<N>, T init)
>{
> init = init + *first;
> return accumulate(++first, count<N-1>(), init);
>}
>template <class InputIterator, class T>
>inline T
>accumulate(InputIterator first, count<0>, T init) { return init; }
># 178 "/usr/local/include/mtl/fast.h" 3
>template <int N, class InputIterator, class T, class BinaryOperation>
>inline T
>accumulate(InputIterator first, count<N>, T init, BinaryOperation binary_op)
>{
> init = binary_op (init, *first);
> return accumulate(++first, count<N-1>(), init, binary_op);
>}
>template <class InputIterator, class T, class BinaryOperation>
>inline T
>accumulate(InputIterator first, count<0>, T init, BinaryOperation binary_op)
>{ return init; }
># 197 "/usr/local/include/mtl/fast.h" 3
>template <int N, class InIter1, class InIter2, class T, class BinOp1, class BinOp2>
>inline
>T inner_product (InIter1 first1, count<N>, InIter2 first2, T init,
> BinOp1 binary_op1, BinOp2 binary_op2)
>{
> init = binary_op1 (init, binary_op2 (*first1, *first2));
> return inner_product(++first1, count<N-1>(), ++first2, init,
> binary_op1, binary_op2);
>}
>
>template <class InIter1, class InIter2, class T, class BinOp1, class BinOp2>
>inline
>T inner_product (InIter1, count<0>, InIter2, T init, BinOp1, BinOp2)
>{
> return init;
>}
>
>
>
>
>
>
>
>template <int N, class InIter1, class InIter2, class T>
>inline
>T inner_product (InIter1 first1, count<N>, InIter2 first2, T init)
>{
> return inner_product(first1, count<N>(), first2, init,
> std::plus<T>(), std::multiplies<T>());
>}
>
>
>
>
>
>}
># 25 "/usr/local/include/mtl/mtl.h" 2 3
># 1 "/usr/local/include/mtl/dense1D.h" 1 3
># 18 "/usr/local/include/mtl/dense1D.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/utility" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/utility" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/utility" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_relops.h" 1 3
># 74 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_relops.h" 3
>namespace std
>{
> namespace rel_ops
> {
># 90 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator!=(const _Tp& __x, const _Tp& __y)
> { return !(__x == __y); }
># 103 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>(const _Tp& __x, const _Tp& __y)
> { return __y < __x; }
># 116 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator<=(const _Tp& __x, const _Tp& __y)
> { return !(__y < __x); }
># 129 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>=(const _Tp& __x, const _Tp& __y)
> { return !(__x < __y); }
>
> }
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/utility" 2 3
># 19 "/usr/local/include/mtl/dense1D.h" 2 3
>
># 1 "/usr/local/include/mtl/refcnt_ptr.h" 1 3
># 19 "/usr/local/include/mtl/refcnt_ptr.h" 3
># 1 "/usr/local/include/mtl/mtl_exception.h" 1 3
># 20 "/usr/local/include/mtl/refcnt_ptr.h" 2 3
>
>namespace mtl {
>
>
>template <class Object>
>class refcnt_ptr {
> typedef refcnt_ptr<Object> self;
>public:
>
> inline refcnt_ptr() : object(0), count(0) { }
>
> inline refcnt_ptr(Object* c)
> : object(c), count(0) {
> if ( object )
> count = new int(1);
> }
>
>
> inline refcnt_ptr(const self& x) : object(x.object), count(x.count) {
> inc();
> }
>
> inline ~refcnt_ptr() { dec(); }
>
> inline self& operator=(Object* c) {
> if (object) dec();
> object = c;
> count = new int(1);
> return *this;
> }
>
> inline self& operator=(const self& x) {
> if (this == &x)
> return *this;
> if (object) dec();
> object = x.object;
> count = x.count;
> inc();
> return *this;
> }
>
> inline Object& operator*() {
> ;
> ;
> return *object;
> }
>
> inline const Object& operator*() const {
> ;
> ;
> return *object;
> }
>
> inline Object* operator->() {
> ;
> ;
> return object;
> }
>
> inline const Object* operator->() const {
> ;
> ;
> return object;
> }
>
> inline void inc() { if (count) (*count)++; }
>
> inline void dec() {
> if (count) {
> (*count)--;
> if (*count <= 0) {
> delete object;
> delete count;
> }
> }
> }
>
>protected:
>
> Object* object;
> int* count;
>};
>
>}
># 21 "/usr/local/include/mtl/dense1D.h" 2 3
># 1 "/usr/local/include/mtl/dense_iterator.h" 1 3
># 18 "/usr/local/include/mtl/dense_iterator.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 19 "/usr/local/include/mtl/dense_iterator.h" 2 3
># 1 "/usr/local/include/mtl/meta_if.h" 1 3
># 25 "/usr/local/include/mtl/meta_if.h" 3
>namespace mtl {
>
>
>
>
> template <int cond, class A, class B>
> struct IF { };
> template <class A, class B>
> struct IF<0, A, B> { typedef B RET; };
> template <class A, class B>
> struct IF<1, A, B> { typedef A RET; };
># 96 "/usr/local/include/mtl/meta_if.h" 3
>}
># 20 "/usr/local/include/mtl/dense_iterator.h" 2 3
>
>
>namespace mtl {
># 286 "/usr/local/include/mtl/dense_iterator.h" 3
>template <class RandomAccessIterator, int IND_OFFSET=0, class SizeType=int>
>class dense_iterator {
> typedef dense_iterator self;
>public:
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::value_type value_type;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::iterator_category iterator_category;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::difference_type difference_type;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::pointer pointer;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::reference reference;
>
> typedef difference_type Distance;
>
> typedef SizeType size_type;
>
>
>
>
>
> RandomAccessIterator start;
> size_type pos;
> size_type start_index;
>
>public:
>
>
> inline size_type index() const {
> return pos + start_index + IND_OFFSET;
> }
>
> inline dense_iterator() : pos(0), start_index(0) {}
>
>
> inline dense_iterator(RandomAccessIterator s,
> size_type i, size_type first_index = 0)
> : start(s), pos(i), start_index(first_index) { }
>
> inline dense_iterator (const self& x)
> : start(x.start), pos(x.pos), start_index(x.start_index) {}
>
> template <class SELF>
> inline dense_iterator (const SELF& x)
> : start(x.start), pos(x.pos), start_index(x.start_index) {}
>
>
> inline self& operator=(const self& x) {
> start = x.start;
> pos = x.pos;
> start_index = x.start_index;
> return *this;
> }
>
> inline ~dense_iterator () { }
>
>
> inline RandomAccessIterator base() const { return start + pos; }
>
> inline operator RandomAccessIterator() const { return start + pos; }
>
> inline reference operator*() const { return *(start + pos); }
>
> inline pointer operator-> () const { return start + pos; }
>
> inline self& operator++ () { ++pos; return *this; }
>
> inline self operator++ (int) { self tmp = *this; ++pos; return tmp; }
>
> inline self& operator-- () { --pos; return *this; }
>
> inline self operator-- (int) { self tmp = *this; --pos; return tmp; }
>
> inline self operator+ (Distance n) const { return self(start, pos + n); }
>
> inline self& operator+= (Distance n) { pos += n; return *this; }
>
> inline self operator- (Distance n) const { return self(start, pos - n); }
>
> inline difference_type operator- (const self& x) const {
> return base() - x.base(); }
>
> inline self& operator-= (Distance n) { pos -= n; return *this; }
>
> inline bool operator!= (const self& x) const { return pos != x.pos; }
>
> inline bool operator < (const self& x) const { return pos < x.pos; }
>
> inline bool operator > (const self& x) const { return pos > x.pos; }
>
> inline bool operator== (const self& x) const { return pos == x.pos; }
>
> inline bool operator<= (const self& x) const { return pos <= x.pos; }
>
> inline bool operator>= (const self& x) const { return pos >= x.pos; }
>
> inline reference operator[] (Distance n) const {
> return *(start + pos + n);
> }
>};
>
>
>template <class T, int OS, class ST>
>inline
>dense_iterator<T>
>operator+ (typename dense_iterator<T,OS,ST>::size_type n,
> const dense_iterator<T,OS,ST> &x)
>{
> return dense_iterator<T,OS,ST>(x.base(), n);
>}
>
>
>
>
>
>}
># 22 "/usr/local/include/mtl/dense1D.h" 2 3
># 1 "/usr/local/include/mtl/reverse_iter.h" 1 3
># 16 "/usr/local/include/mtl/reverse_iter.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 17 "/usr/local/include/mtl/reverse_iter.h" 2 3
>
>
>
>namespace mtl {
>
>
>
>template <class Iter>
>class reverse_iter : public std::reverse_iterator<Iter> {
> typedef std::reverse_iterator<Iter> super;
>
>
>
>
>
>
>
>public:
> typedef typename super::value_type value_type;
>
>
>
>
>
>
> typedef typename super::difference_type difference_type;
> typedef typename super::reference reference;
>
>
>
> typedef typename super::iterator_category iterator_category;
>
> inline reverse_iter() {}
>
> inline reverse_iter(const reverse_iter& x) : super(x) { }
>
> inline explicit
> reverse_iter(Iter x) : super(x) {}
>
> inline difference_type index() const {
> Iter tmp = super::current;
> return (--tmp).index();
> }
> inline difference_type row() const {
> Iter tmp = super::current;
> return (--tmp).row();
> }
> inline difference_type column() const {
> Iter tmp = super::current;
> return (--tmp).column();
> }
>
>};
>
>}
># 23 "/usr/local/include/mtl/dense1D.h" 2 3
># 1 "/usr/local/include/mtl/light1D.h" 1 3
># 15 "/usr/local/include/mtl/light1D.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 16 "/usr/local/include/mtl/light1D.h" 2 3
>
>
>
>
>
># 1 "/usr/local/include/mtl/scaled1D.h" 1 3
># 19 "/usr/local/include/mtl/scaled1D.h" 3
># 1 "/usr/local/include/mtl/scale_iterator.h" 1 3
># 20 "/usr/local/include/mtl/scale_iterator.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 21 "/usr/local/include/mtl/scale_iterator.h" 2 3
>
>
>namespace mtl {
># 47 "/usr/local/include/mtl/scale_iterator.h" 3
>template <class RandomAccessIterator, class T>
>class scale_iterator {
> typedef scale_iterator<RandomAccessIterator, T> self;
>public:
>
> typedef typename std::iterator_traits<RandomAccessIterator>::value_type
> value_type;
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::difference_type
> difference_type;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::pointer pointer;
>
>
>
>
>
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::iterator_category
> iterator_category;
>
> typedef difference_type Distance;
> typedef RandomAccessIterator iterator_type;
>
> typedef value_type reference;
> typedef value_type const_reference;
>
>
>
> inline scale_iterator() : alpha(0) { }
>
>
> inline scale_iterator(const RandomAccessIterator& x)
> : current(x), alpha(1) { }
>
>
>
> inline scale_iterator(const RandomAccessIterator& x, const value_type& a)
> : current(x), alpha(a) { }
>
>
>
> inline scale_iterator(const self& x)
> : current(x.current), alpha(x.alpha) { }
>
>
>
> inline int index() const { return current.index(); }
>
>
>
> inline operator RandomAccessIterator() { return current; }
>
>
>
> inline RandomAccessIterator base() const { return current; }
>
>
>
> inline value_type operator*() const { return alpha * *current; }
>
>
>
> inline self& operator++ () { ++current; return *this; }
>
>
>
> inline self operator++ (int) { self tmp = *this; ++current; return tmp; }
>
>
>
> inline self& operator-- () { --current; return *this; }
>
>
>
> inline self operator-- (int) { self tmp = *this; --current; return tmp; }
>
>
>
> inline self operator+ (Distance n) const {
> self c = current;
> c += n;
> return self(c.current, alpha);
> }
>
>
>
> inline self& operator+= (Distance n) { current += n; return *this; }
>
>
>
> inline self operator- (Distance n) const {
> return self (current - n, alpha);
> }
>
> inline difference_type operator- (const self& x) const {
> return current - x.current;
> }
>
>
>
> inline self& operator-= (Distance n) { current -= n; return *this; }
>
>
> inline value_type operator[] (Distance n) const {
> return alpha * *(current + n);
> }
>
>
> inline bool operator==(const self& x) const { return current == x.current; }
>
>
>
> inline bool operator!=(const self& x) const { return current != x.current; }
>
>
>
> inline bool operator<(const self& x) const { return current < x.current; }
>
>protected:
> RandomAccessIterator current;
> T alpha;
>};
># 184 "/usr/local/include/mtl/scale_iterator.h" 3
>}
># 20 "/usr/local/include/mtl/scaled1D.h" 2 3
>
>
>
>namespace mtl {
># 39 "/usr/local/include/mtl/scaled1D.h" 3
>template <class RandomAccessContainerRef>
>class scaled1D {
> typedef RandomAccessContainerRef Vector;
> typedef scaled1D<Vector> self;
>public:
>
>
>
> enum { N = RandomAccessContainerRef::N };
>
>
> typedef typename Vector::value_type value_type;
>
> typedef typename Vector::size_type size_type;
>
>
> typedef typename Vector::dimension dimension;
>
>
> typedef scale_iterator<typename Vector::iterator, value_type> iterator;
>
>
> typedef scale_iterator<typename Vector::const_iterator, value_type> const_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
> typedef typename const_iterator::pointer pointer;
>
>
> typedef typename const_iterator::reference reference;
>
>
>
> typedef typename const_iterator::reference const_reference;
>
> typedef typename const_iterator::difference_type difference_type;
>
>
>
> typedef scaled1D< self > scaled_type;
>
>
> typedef typename Vector::sparsity sparsity;
>
> typedef scaled1D< typename Vector::subrange_type > subrange_type;
>
>
> typedef typename Vector::IndexArray IndexArray;
>
> typedef typename Vector::IndexArrayRef IndexArrayRef;
>
>
>
>
> inline scaled1D() { }
>
>
> inline scaled1D(const Vector& r, value_type scale_)
> : rep(r), scale(scale_) { }
>
> inline scaled1D(const Vector& r, value_type scale_, do_scaled)
> : rep(r), scale(scale_) { }
>
>
> inline scaled1D(const self& x) : rep(x.rep), scale(x.scale) { }
>
>
> inline self& operator=(const self& x) {
> rep = x.rep; scale = x.scale; return *this;
> }
>
> inline ~scaled1D() { }
>
>
>
>
> inline operator Vector&() { return rep; }
>
>
>
> inline const_iterator begin() const {
> return const_iterator(rep.begin(), scale);
> }
>
>
> inline const_iterator end() const {
> return const_iterator(rep.end(), scale);
> }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
> inline const_reference operator[](size_type i) const {
> return rep[i] * scale;
> }
>
>
>
>
> inline subrange_type operator()(size_type s, size_type f) const {
> return subrange_type(rep(s,f), scale);
> }
>
>
>
> inline size_type size() const { return rep.size(); }
>
>
>
> inline size_type nnz() const { return rep.nnz(); }
>
> inline self& adjust_index(size_type i) { rep.adjust_index(i); return *this; }
>
>protected:
> Vector rep;
> value_type scale;
>};
># 187 "/usr/local/include/mtl/scaled1D.h" 3
>template <class Scalable, class T> inline
>typename Scalable::scaled_type
>scaled(const Scalable& A, const T& alpha)
>{
> typedef typename Scalable::scaled_type scaled_type;
> return scaled_type(A, alpha, do_scaled());
>}
>
>
>}
># 22 "/usr/local/include/mtl/light1D.h" 2 3
>
>
>namespace mtl {
># 35 "/usr/local/include/mtl/light1D.h" 3
>template <class T, int NN = 0, int IND_OFFSET = 0>
>class light1D {
> typedef light1D self;
>public:
> enum { N = NN };
>
> typedef light1D<int> IndexArray;
>
>
>
>
> typedef dense_tag sparsity;
>
> typedef scaled1D< light1D<T> > scaled_type;
>
> typedef T value_type;
>
> typedef T& reference;
>
> typedef T* pointer;
>
> typedef const T& const_reference;
>
> typedef const T* const_pointer;
>
> typedef int size_type;
> typedef ptrdiff_t difference_type;
># 82 "/usr/local/include/mtl/light1D.h" 3
> typedef dense_iterator<T*, IND_OFFSET> iterator;
>
> typedef dense_iterator<const T*, IND_OFFSET> const_iterator;
>
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
> typedef self IndexArrayRef;
>
> typedef self subrange_type;
>
> typedef oned_tag dimension;
>
>
>
>
>
>
> inline light1D() : rep(0), size_(0), first(0) { }
>
>
> inline light1D(T* data, size_type n, size_type start = 0)
> : rep(data), size_(n), first(start) { }
>
>
> inline light1D(const self& x)
> : rep(x.rep), size_(x.size_), first(x.first) { }
>
> inline ~light1D() { }
># 122 "/usr/local/include/mtl/light1D.h" 3
> inline iterator begin() { return iterator(rep, 0, first); }
>
> inline iterator end() { return iterator(rep, size_, first); }
>
> inline const_iterator begin() const {
> return const_iterator(rep, 0, first);
> }
>
> inline const_iterator end() const{
> return const_iterator(rep, size_, first);
> }
>
> inline reverse_iterator rbegin() {
>
> return reverse_iterator(end());
> }
>
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> inline const_reverse_iterator rend() const{
> return const_reverse_iterator(begin());
> }
>
>
>
>
> inline reference operator[](size_type n) { return rep[n - first]; }
>
> inline const_reference operator[](size_type n) const {
> return rep[n - first];
> }
>
> inline subrange_type operator()(size_type s, size_type f) const {
> return subrange_type(rep + s - first, f - s, 0);
> }
>
>
>
>
> inline int size() const { return size_; }
>
> inline int nnz() const { return size_; }
>
> inline void resize(int n) {
> if (rep) delete [] rep;
> size_ = n;
> rep = new T[size_];
> }
> inline self& adjust_index(size_type delta) {
> first += delta;
> return *this;
> }
>
>
> inline T* data() const { return rep; }
>
>protected:
> T* rep;
> int size_;
> int first;
>};
>
>}
># 24 "/usr/local/include/mtl/dense1D.h" 2 3
># 60 "/usr/local/include/mtl/dense1D.h" 3
>namespace mtl {
># 80 "/usr/local/include/mtl/dense1D.h" 3
>template <class T, int NN = 0>
>class dense1D {
>
>
>
> typedef dense1D<T,NN> self;
> typedef std::vector<T> rep_type;
>
> typedef refcnt_ptr< rep_type > rep_ptr;
>public:
>
> enum { N = NN };
>
>
> typedef oned_tag dimension;
>
>
> typedef dense_tag sparsity;
>
>
> typedef scaled1D< self > scaled_type;
>
>
> typedef typename rep_type::value_type value_type;
>
>
> typedef typename rep_type::reference reference;
>
>
> typedef typename rep_type::const_reference const_reference;
>
>
>
> typedef typename rep_type::pointer pointer;
>
>
>
>
>
> typedef typename rep_type::size_type size_type;
>
>
> typedef typename rep_type::difference_type difference_type;
>
>
>
> typedef dense_iterator<typename rep_type::iterator> iterator;
>
>
> typedef dense_iterator<typename rep_type::const_iterator> const_iterator;
>
>
>
>
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
> typedef light1D<value_type> subrange_type;
>
> typedef std::pair<size_type,size_type> range_type;
>
>
>
> typedef self Vec;
>
> typedef size_type Vec_size_type;
> typedef difference_type Vec_difference_type;
> typedef iterator Vec_iterator;
> typedef const_iterator Vec_const_iterator;
> typedef value_type Vec_value_type;
>
>
> class IndexArray {
> public:
>
> typedef Vec_size_type size_type;
> typedef Vec_difference_type difference_type;
> typedef Vec_size_type value_type;
>
> class iterator {
> public:
> typedef size_type value_type;
> typedef size_type reference;
> typedef size_type* pointer;
> typedef Vec_difference_type difference_type;
> typedef typename std::iterator_traits<Vec_iterator>::iterator_category
> iterator_category;
> iterator(Vec_iterator iter, Vec_iterator e) : i(iter), end(e) {
> while (*i == Vec_value_type(0)) ++i;
> }
> reference operator*() const { return i.index(); }
> iterator& operator++() {
> ++i; while (*i == Vec_value_type(0) && i != end) ++i;
> return *this; }
> iterator operator++(int) { iterator t = *this; ++(*this); return t; }
> iterator& operator--() {
> --i; while (*i == Vec_value_type(0) && i != end) --i;
> return *this; }
> iterator operator--(int) { iterator t = *this; --(*this); return t; }
> difference_type operator-(const iterator& x) const { return i - x.i; }
> bool operator==(const iterator& x) const { return i == x.i; }
> bool operator!=(const iterator& x) const { return i != x.i; }
> bool operator<(const iterator& x) const { return i < x.i; }
> Vec_iterator i;
> Vec_iterator end;
> };
> class const_iterator {
> public:
> typedef size_type value_type;
> typedef size_type reference;
> typedef size_type* pointer;
> typedef Vec_difference_type difference_type;
> typedef typename std::iterator_traits<Vec_iterator>::iterator_category iterator_category;
> const_iterator(Vec_const_iterator iter, Vec_const_iterator e)
> : i(iter), end(e) {
> while (*i == Vec_value_type(0) && i != end) ++i;
> }
> reference operator*() const { return i.index(); }
> const_iterator& operator++() {
> ++i; while (*i == Vec_value_type(0) && i != end) ++i;
> return *this; }
> const_iterator operator++(int) {
> const_iterator t = *this; ++(*this); return t; }
> const_iterator& operator--() {
> --i; while (*i == Vec_value_type(0)) --i;
> return *this; }
> const_iterator operator--(int) {
> const_iterator t = *this; --(*this); return t; }
> difference_type operator-(const const_iterator& x) const {
> return i - x.i; }
> bool operator==(const const_iterator& x) const { return i == x.i; }
> bool operator!=(const const_iterator& x) const { return i != x.i; }
> bool operator<(const const_iterator& x) const { return i < x.i; }
> Vec_const_iterator i;
> Vec_const_iterator end;
> };
>
> inline IndexArray(const Vec& v) : vec((Vec*)&v) { }
> inline iterator begin() { return iterator(vec->begin(), vec->end()); }
> inline iterator end() { return iterator(vec->end(), vec->end()); }
> inline const_iterator begin() const{
> return const_iterator(((const Vec*)vec)->begin(),
> ((const Vec*)vec)->end());
> }
> inline const_iterator end() const {
> return const_iterator(((const Vec*)vec)->end(),
> ((const Vec*)vec)->end());
> }
>
> size_type size() const {
> size_type s = 0;
> Vec_const_iterator i;
> for (i = ((const Vec*)vec)->begin(); i != ((const Vec*)vec)->end(); ++i)
> if (*i != Vec_value_type(0)) ++s;
> return s;
> }
>
> Vec* vec;
> };
>
> typedef IndexArray IndexArrayRef;
># 256 "/usr/local/include/mtl/dense1D.h" 3
> inline dense1D() : rep(new rep_type()), first(0) { }
>
>
>
> inline dense1D(size_type n) : rep(new rep_type(n)), first(0) { }
># 270 "/usr/local/include/mtl/dense1D.h" 3
> inline dense1D(size_type n, const value_type& init)
> : rep(new rep_type(n,init)), first(0) { }
>
>
>
> inline dense1D(const self& x) : rep(x.rep), first(x.first) { }
>
>
>
> inline ~dense1D() { }
>
>
>
> inline self& operator=(const self& x) {
> rep = x.rep; first = x.first;
> return *this;
> }
>
>
>
>
>
>
>
> inline iterator begin() { return iterator(rep->begin(),0, first); }
>
>
> inline iterator end() { return iterator(rep->begin(), rep->size(), first); }
>
>
> inline const_iterator begin() const {
> return const_iterator(rep->begin(), 0, first);
> }
>
>
> inline const_iterator end() const{
> return const_iterator(rep->begin(), rep->size(), first);
> }
>
>
> inline reverse_iterator rbegin() { return reverse_iterator(end()); }
>
>
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
>
> inline const_reverse_iterator rend() const{
> return const_reverse_iterator(begin());
> }
>
>
>
>
>
> inline reference operator[](size_type i) {
> ;
> return (*rep)[i - first];
> }
>
>
>
> inline const_reference operator[](size_type i) const {
> ;
> return (*rep)[i - first];
> }
>
> inline subrange_type operator()(range_type r) const {
> return subrange_type(data() + r.first - first,
> r.second - r.first,
> 0);
> }
> inline subrange_type operator()(size_type s, size_type f) const
> 
> {
> return subrange_type(const_cast<value_type*>(data()) + s - first,
> f - s,
> 0);
> }
>
>
>
>
>
> inline size_type size() const { return rep->size(); }
>
> inline size_type nnz() const { return rep->size(); }
>
> inline void resize(size_type n) { rep->resize(n); }
> inline void resize(size_type n, const T& x) { rep->resize(n, x); }
>
> inline size_type capacity() const { return rep->capacity(); }
>
>
> void reserve(size_type n) { rep->reserve(n); }
>
>
> inline const value_type* data() const { return &(*rep)[0]; }
> inline pointer data() { return &(*rep)[0]; }
>
>
>
> iterator insert (iterator position, const value_type& x = value_type()) {
> return iterator(rep->insert(position.base(), x), position.index()+1);
>
> }
>
> void insert (iterator position, size_type n,
> const value_type& x = value_type()) {
> rep->insert(position.base(), n, x);
>
>
>
> }
> void push_back(const value_type& x) { rep->push_back(x); }
>
> inline IndexArrayRef nz_struct() const {
> return IndexArrayRef(*this);
> }
>
> self& adjust_index(size_type delta) {
> first += delta;
> return *this;
> }
>
>protected:
>
> rep_ptr rep;
> size_type first;
>
>
>};
>
>
>}
># 26 "/usr/local/include/mtl/mtl.h" 2 3
>
>
># 1 "/usr/local/include/mtl/transform_iterator.h" 1 3
># 14 "/usr/local/include/mtl/transform_iterator.h" 3
># 1 "/usr/local/include/mtl/iterator_adaptor.h" 1 3
># 17 "/usr/local/include/mtl/iterator_adaptor.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 18 "/usr/local/include/mtl/iterator_adaptor.h" 2 3
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 19 "/usr/local/include/mtl/iterator_adaptor.h" 2 3
># 55 "/usr/local/include/mtl/iterator_adaptor.h" 3
>template <class SubClass, class Iterator>
>class iterator_adaptor {
> typedef iterator_adaptor<SubClass, Iterator> self;
>public:
>
>
> typedef typename std::iterator_traits<Iterator>::value_type value_type;
># 72 "/usr/local/include/mtl/iterator_adaptor.h" 3
> typedef typename std::iterator_traits<Iterator>::difference_type
> difference_type;
>
> typedef typename std::iterator_traits<Iterator>::pointer pointer;
>
>
> typedef typename std::iterator_traits<Iterator>::reference reference;
>
>
> typedef typename std::iterator_traits<Iterator>::iterator_category
> iterator_category;
>
>
> typedef difference_type Distance;
> typedef Iterator iterator_type;
>
> inline difference_type index() const { return iter.index(); }
>
>
>
> inline iterator_adaptor(SubClass& me_)
> : me(&me_) { }
>
>
>
> inline iterator_adaptor(SubClass& me_, const Iterator& x)
> : iter(x), me(&me_) { }
>
> inline iterator_adaptor(const self& x) {
> me = 0; iter = x.iter;
> }
>
>
> inline ~iterator_adaptor() { }
>
>
>
> inline self& operator=(const self& x) {
> iter = x.iter; return *this;
> }
>
>
>
> inline operator Iterator() { return iter; }
>
>
>
> inline Iterator base() const { return iter; }
>
>
>
> inline reference operator*() const { return *iter; }
>
>
>
> inline SubClass& operator++() { ++iter; return *me; }
>
>
>
> inline SubClass operator++(int) {
> SubClass tmp = (*me);
> ++(*me);
> return tmp;
> }
>
>
>
> inline SubClass& operator--() { --iter; return *me; }
>
>
>
> inline SubClass operator--(int) {
> SubClass tmp = (*me);
> --(*me);
> return tmp;
> }
>
>
>
> inline SubClass operator+(Distance n) const {
> SubClass tmp = (*me);
> tmp += n;
> return tmp;
> }
>
>
>
> inline SubClass& operator+=(Distance n) {
> std::advance(iter, n);
> return (*me);
> }
>
>
>
> inline SubClass operator-(Distance n) const {
> SubClass tmp = (*me);
> tmp -= n;
> return tmp;
> }
>
>
>
> inline SubClass& operator-=(Distance n) {
> std::advance(iter, -n);
> return (*me);
> }
>
>
> inline value_type operator[](Distance n) const {
> SubClass tmp = (*me);
> return *(tmp += n);
> }
>
> inline Distance operator-(const SubClass& y) {
> return iter - y.iter;
> }
># 201 "/usr/local/include/mtl/iterator_adaptor.h" 3
> inline bool operator==(const SubClass& y) const {
> return iter == y.iter;
> }
>
>
>
> inline bool operator!=(const SubClass& y) const {
> return !(iter == y.iter);
> }
>
>
>
> inline bool operator<(const SubClass& y) const {
> return iter < y.iter;
> }
>
>protected:
> Iterator iter;
> SubClass* me;
>};
># 15 "/usr/local/include/mtl/transform_iterator.h" 2 3
># 63 "/usr/local/include/mtl/transform_iterator.h" 3
>template <class RandomAccessIterator, class UnaryFunction>
>class transform_iterator {
> typedef transform_iterator self;
>public:
>
> typedef typename UnaryFunction::result_type value_type;
>
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::difference_type
> difference_type;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::pointer
> pointer;
>
>
>
>
>
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::iterator_category
> iterator_category;
>
> typedef difference_type Distance;
> typedef RandomAccessIterator iterator_type;
>
> typedef value_type reference;
> typedef value_type const_reference;
>
>
>
> inline transform_iterator() { }
>
>
>
> inline transform_iterator(const RandomAccessIterator& x, UnaryFunction op)
> : current(x), f(op) { }
>
>
>
> inline transform_iterator(const self& x)
> : current(x.current), f(x.f) { }
>
>
>
> inline int index() const { return current.index(); }
>
>
>
> inline operator RandomAccessIterator() { return current; }
>
>
>
> inline RandomAccessIterator base() const { return current; }
>
>
>
> inline value_type operator*() const { return f(*current); }
>
>
>
> inline self& operator++ () { ++current; return *this; }
>
>
>
> inline self operator++ (int) { self tmp = *this; ++current; return tmp; }
>
>
>
> inline self& operator-- () { --current; return *this; }
>
>
>
> inline self operator-- (int) { self tmp = *this; --current; return tmp; }
>
>
>
> inline self operator+ (Distance n) const {
> self c = current;
> c += n;
> return self (c, f);
> }
>
>
>
> inline self& operator+= (Distance n) { current += n; return *this; }
>
>
>
> inline self operator- (Distance n) const {
> return self (current - n, f);
> }
>
> inline difference_type operator- (const self& x) const {
> return current - x.current;
> }
>
>
>
> inline self& operator-= (Distance n) { current -= n; return *this; }
>
>
> inline value_type operator[] (Distance n) const {
> return f(*(current + n));
> }
>
>
> inline bool operator==(const self& x) const { return current == x.current; }
>
>
>
> inline bool operator!=(const self& x) const { return current != x.current; }
>
>
>
> inline bool operator<(const self& x) const { return current < x.current; }
>
>protected:
> RandomAccessIterator current;
> UnaryFunction f;
>};
>
>
>
>
>
>template <class Iterator, class UnaryFunction> inline
>transform_iterator<Iterator,UnaryFunction>
>trans_iter(Iterator i, UnaryFunction op) {
> return transform_iterator<Iterator,UnaryFunction>(i, op);
>}
># 214 "/usr/local/include/mtl/transform_iterator.h" 3
>template <class RandomAccessIterator>
>class constant_stride_generator {
> typedef constant_stride_generator<RandomAccessIterator> self;
> typedef typename std::iterator_traits<RandomAccessIterator>::difference_type
> Distance;
>public:
> inline constant_stride_generator(Distance s) : stride_(s) { }
> inline constant_stride_generator(const self& x) : stride_(x.stride_) { }
> inline void inc(RandomAccessIterator& i) { i += stride_; }
> inline void dec(RandomAccessIterator& i) { i -= stride_; }
> inline void advance(RandomAccessIterator& i, int n) { i += n * stride_; }
>
> inline Distance diff(const RandomAccessIterator& x,
> const RandomAccessIterator& y,
> const self& ) const {
> return (x - y) / stride_;
> }
>private:
> Distance stride_;
>};
>
>
>
>
>
>template <class RandomAccessIterator, class StrideGen>
>class general_stride_iterator
> : public iterator_adaptor< general_stride_iterator<RandomAccessIterator,
> StrideGen>,
> RandomAccessIterator >
>{
> typedef general_stride_iterator<RandomAccessIterator, StrideGen> self;
> typedef iterator_adaptor< self, RandomAccessIterator> super;
>public:
> typedef typename super::Distance Distance;
>
> inline general_stride_iterator(RandomAccessIterator i, StrideGen s)
> : super(*this, i), stride_gen(s) { }
> inline self& operator++() {
> stride_gen.inc(super::iter);
> return *this;
> }
> inline self& operator--() {
> stride_gen.dec(super::iter);
> return *this;
> }
> inline self& operator+=(Distance n) {
> stride_gen.advance(super::iter, n);
> return *this;
> }
> inline self& operator-=(Distance n) {
> stride_gen.advance(super::iter, -n);
> return *this;
> }
>
> inline Distance diff(const self& y) const {
> return stride_gen.diff(super::iter, y.super::iter, y.stride_gen);
> }
>
> inline friend Distance operator-(const self& x, const self& y) {
> return x.diff(y);
> }
>
>protected:
> StrideGen stride_gen;
>};
>
>
>template <class RandomAccessIterator>
>class stride_iterator
> : public general_stride_iterator<RandomAccessIterator,
> constant_stride_generator<RandomAccessIterator> >
>
>{
> typedef general_stride_iterator<RandomAccessIterator,
> constant_stride_generator<RandomAccessIterator> > super;
>public:
> typedef typename super::difference_type difference_type;
> inline stride_iterator(RandomAccessIterator i, difference_type s)
> : super(i, constant_stride_generator<RandomAccessIterator>(s)) { }
>};
># 29 "/usr/local/include/mtl/mtl.h" 2 3
>
># 1 "/usr/local/include/mtl/abs.h" 1 3
># 31 "/usr/local/include/mtl/mtl.h" 2 3
># 40 "/usr/local/include/mtl/mtl.h" 3
># 1 "/usr/local/include/mtl/matrix.h" 1 3
># 23 "/usr/local/include/mtl/matrix.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/set" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/set" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/set" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
>namespace std
>{
>
> template<class _Key, class _Compare = std::less<_Key>,
> class _Alloc = std::allocator<_Key> >
> class set;
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y);
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y);
># 106 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> template<class _Key, class _Compare, class _Alloc>
> class set
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
>
>
>
> typedef _Key key_type;
> typedef _Key value_type;
> typedef _Compare key_compare;
> typedef _Compare value_compare;
> typedef _Alloc allocator_type;
>
>
> private:
> typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
> key_compare, _Key_alloc_type> _Rep_type;
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Key_alloc_type::pointer pointer;
> typedef typename _Key_alloc_type::const_pointer const_pointer;
> typedef typename _Key_alloc_type::reference reference;
> typedef typename _Key_alloc_type::const_reference const_reference;
>
>
>
> typedef typename _Rep_type::const_iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
>
>
>
>
> set()
> : _M_t(_Compare(), allocator_type()) {}
>
>
>
>
>
>
>
> explicit
> set(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) {}
># 177 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> template<class _InputIterator>
> set(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_unique(__first, __last); }
># 193 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> template<class _InputIterator>
> set(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a)
> { _M_t.insert_unique(__first, __last); }
># 207 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> set(const set<_Key,_Compare,_Alloc>& __x)
> : _M_t(__x._M_t) { }
># 217 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> set<_Key,_Compare,_Alloc>&
> operator=(const set<_Key, _Compare, _Alloc>& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
> value_compare
> value_comp() const
> { return _M_t.key_comp(); }
>
> allocator_type
> get_allocator() const
> { return _M_t.get_allocator(); }
>
>
>
>
>
> iterator
> begin() const
> { return _M_t.begin(); }
>
>
>
>
>
> iterator
> end() const
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() const
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend() const
> { return _M_t.rend(); }
>
>
> bool
> empty() const
> { return _M_t.empty(); }
>
>
> size_type
> size() const
> { return _M_t.size(); }
>
>
> size_type
> max_size() const
> { return _M_t.max_size(); }
># 299 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> void
> swap(set<_Key,_Compare,_Alloc>& __x)
> { _M_t.swap(__x._M_t); }
># 317 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> std::pair<iterator,bool>
> insert(const value_type& __x)
> {
> std::pair<typename _Rep_type::iterator, bool> __p =
> _M_t.insert_unique(__x);
> return std::pair<iterator, bool>(__p.first, __p.second);
> }
># 344 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> iterator
> insert(iterator __position, const value_type& __x)
> { return _M_t.insert_unique(__position, __x); }
># 356 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> template<class _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_unique(__first, __last); }
># 370 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> void
> erase(iterator __position)
> { _M_t.erase(__position); }
># 385 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 400 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> void
> erase(iterator __first, iterator __last)
> { _M_t.erase(__first, __last); }
>
>
>
>
>
>
>
> void
> clear()
> { _M_t.clear(); }
># 424 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 442 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
>
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 463 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
>
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
># 479 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 504 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
>
> template<class _K1, class _C1, class _A1>
> friend bool
> operator== (const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
>
> template<class _K1, class _C1, class _A1>
> friend bool
> operator< (const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
> };
># 533 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 550 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_set.h" 3
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator!=(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator>(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator<=(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator>=(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline void
> swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/set" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
>namespace std
>{
>
>
> template <class _Key, class _Compare = std::less<_Key>,
> class _Alloc = std::allocator<_Key> >
> class multiset;
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y);
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y);
># 104 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> template <class _Key, class _Compare, class _Alloc>
> class multiset
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
>
> typedef _Key key_type;
> typedef _Key value_type;
> typedef _Compare key_compare;
> typedef _Compare value_compare;
> typedef _Alloc allocator_type;
>
> private:
>
> typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
> key_compare, _Key_alloc_type> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
> typedef typename _Key_alloc_type::pointer pointer;
> typedef typename _Key_alloc_type::const_pointer const_pointer;
> typedef typename _Key_alloc_type::reference reference;
> typedef typename _Key_alloc_type::const_reference const_reference;
>
>
>
> typedef typename _Rep_type::const_iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
>
>
>
>
>
>
> multiset()
> : _M_t(_Compare(), allocator_type()) { }
>
> explicit
> multiset(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) { }
># 168 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> template <class _InputIterator>
> multiset(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_equal(__first, __last); }
># 184 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> template <class _InputIterator>
> multiset(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a)
> { _M_t.insert_equal(__first, __last); }
># 198 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> multiset(const multiset<_Key,_Compare,_Alloc>& __x)
> : _M_t(__x._M_t) { }
># 208 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> multiset<_Key,_Compare,_Alloc>&
> operator=(const multiset<_Key,_Compare,_Alloc>& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
> value_compare
> value_comp() const
> { return _M_t.key_comp(); }
>
> allocator_type
> get_allocator() const
> { return _M_t.get_allocator(); }
>
>
>
>
>
>
> iterator
> begin() const
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> end() const
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() const
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend() const
> { return _M_t.rend(); }
>
>
> bool
> empty() const
> { return _M_t.empty(); }
>
>
> size_type
> size() const
> { return _M_t.size(); }
>
>
> size_type
> max_size() const
> { return _M_t.max_size(); }
># 292 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> void
> swap(multiset<_Key, _Compare, _Alloc>& __x)
> { _M_t.swap(__x._M_t); }
># 308 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> iterator
> insert(const value_type& __x)
> { return _M_t.insert_equal(__x); }
># 332 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> iterator
> insert(iterator __position, const value_type& __x)
> { return _M_t.insert_equal(__position, __x); }
># 344 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> template <class _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_equal(__first, __last); }
># 359 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> void
> erase(iterator __position)
> { _M_t.erase(__position); }
># 374 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 389 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> void
> erase(iterator __first, iterator __last)
> { _M_t.erase(__first, __last); }
>
>
>
>
>
>
>
> void
> clear()
> { _M_t.clear(); }
># 410 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.count(__x); }
># 428 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
>
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 449 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
>
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
># 465 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 490 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
> template <class _K1, class _C1, class _A1>
> friend bool
> operator== (const multiset<_K1, _C1, _A1>&,
> const multiset<_K1, _C1, _A1>&);
>
> template <class _K1, class _C1, class _A1>
> friend bool
> operator< (const multiset<_K1, _C1, _A1>&,
> const multiset<_K1, _C1, _A1>&);
> };
># 520 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 537 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_multiset.h" 3
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator>(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return __y < __x; }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline void
> swap(multiset<_Key, _Compare, _Alloc>& __x,
> multiset<_Key, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/set" 2 3
># 24 "/usr/local/include/mtl/matrix.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/list" 1 3
># 63 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/list" 3
> 
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/list" 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
>namespace std
>{
>
>
>
>
>
>
> struct _List_node_base
> {
> _List_node_base* _M_next;
> _List_node_base* _M_prev;
>
> static void
> swap(_List_node_base& __x, _List_node_base& __y);
>
> void
> transfer(_List_node_base * const __first,
> _List_node_base * const __last);
>
> void
> reverse();
>
> void
> hook(_List_node_base * const __position);
>
> void
> unhook();
> };
>
>
> template<typename _Tp>
> struct _List_node : public _List_node_base
> {
> _Tp _M_data;
> };
># 110 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _Tp>
> struct _List_iterator
> {
> typedef _List_iterator<_Tp> _Self;
> typedef _List_node<_Tp> _Node;
>
> typedef ptrdiff_t difference_type;
> typedef std::bidirectional_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef _Tp* pointer;
> typedef _Tp& reference;
>
> _List_iterator()
> : _M_node() { }
>
> explicit
> _List_iterator(_List_node_base* __x)
> : _M_node(__x) { }
>
>
> reference
> operator*() const
> { return static_cast<_Node*>(_M_node)->_M_data; }
>
> pointer
> operator->() const
> { return &static_cast<_Node*>(_M_node)->_M_data; }
>
> _Self&
> operator++()
> {
> _M_node = _M_node->_M_next;
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_next;
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _M_node->_M_prev;
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_prev;
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
>
> _List_node_base* _M_node;
> };
># 187 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _Tp>
> struct _List_const_iterator
> {
> typedef _List_const_iterator<_Tp> _Self;
> typedef const _List_node<_Tp> _Node;
> typedef _List_iterator<_Tp> iterator;
>
> typedef ptrdiff_t difference_type;
> typedef std::bidirectional_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
>
> _List_const_iterator()
> : _M_node() { }
>
> explicit
> _List_const_iterator(const _List_node_base* __x)
> : _M_node(__x) { }
>
> _List_const_iterator(const iterator& __x)
> : _M_node(__x._M_node) { }
>
>
>
> reference
> operator*() const
> { return static_cast<_Node*>(_M_node)->_M_data; }
>
> pointer
> operator->() const
> { return &static_cast<_Node*>(_M_node)->_M_data; }
>
> _Self&
> operator++()
> {
> _M_node = _M_node->_M_next;
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_next;
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _M_node->_M_prev;
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_prev;
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
>
> const _List_node_base* _M_node;
> };
>
> template<typename _Val>
> inline bool
> operator==(const _List_iterator<_Val>& __x,
> const _List_const_iterator<_Val>& __y)
> { return __x._M_node == __y._M_node; }
>
> template<typename _Val>
> inline bool
> operator!=(const _List_iterator<_Val>& __x,
> const _List_const_iterator<_Val>& __y)
> { return __x._M_node != __y._M_node; }
>
>
>
>
>
>
>
> template<typename _Tp, typename _Alloc>
> class _List_base
> {
> protected:
># 297 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
> _Node_alloc_type;
>
> typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
>
> struct _List_impl
> : public _Node_alloc_type
> {
> _List_node_base _M_node;
>
> _List_impl(const _Node_alloc_type& __a)
> : _Node_alloc_type(__a), _M_node()
> { }
> };
>
> _List_impl _M_impl;
>
> _List_node<_Tp>*
> _M_get_node()
> { return _M_impl._Node_alloc_type::allocate(1); }
>
> void
> _M_put_node(_List_node<_Tp>* __p)
> { _M_impl._Node_alloc_type::deallocate(__p, 1); }
>
> public:
> typedef _Alloc allocator_type;
>
> _Tp_alloc_type
> _M_get_Tp_allocator() const
> { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const
> { return _M_get_Tp_allocator(); }
>
> _List_base(const allocator_type& __a)
> : _M_impl(__a)
> { _M_init(); }
>
>
> ~_List_base()
> { _M_clear(); }
>
> void
> _M_clear();
>
> void
> _M_init()
> {
> this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
> this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
> }
> };
># 397 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class list : protected _List_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _List_base<_Tp, _Alloc> _Base;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
>
> public:
> typedef _Tp value_type;
> typedef typename _Tp_alloc_type::pointer pointer;
> typedef typename _Tp_alloc_type::const_pointer const_pointer;
> typedef typename _Tp_alloc_type::reference reference;
> typedef typename _Tp_alloc_type::const_reference const_reference;
> typedef _List_iterator<_Tp> iterator;
> typedef _List_const_iterator<_Tp> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
>
>
> typedef _List_node<_Tp> _Node;
>
>
>
>
>
>
>
> using _Base::_M_impl;
> using _Base::_M_put_node;
> using _Base::_M_get_node;
> using _Base::_M_get_Tp_allocator;
># 445 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> _Node*
> _M_create_node(const value_type& __x)
> {
> _Node* __p = this->_M_get_node();
> try
> {
> _M_get_Tp_allocator().construct(&__p->_M_data, __x);
> }
> catch(...)
> {
> _M_put_node(__p);
> throw;
> }
> return __p;
> }
>
> public:
>
>
>
>
>
> explicit
> list(const allocator_type& __a = allocator_type())
> : _Base(__a) { }
># 478 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> explicit
> list(size_type __n, const value_type& __value = value_type(),
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { this->insert(begin(), __n, __value); }
># 491 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> list(const list& __x)
> : _Base(__x.get_allocator())
> { this->insert(begin(), __x.begin(), __x.end()); }
># 509 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _InputIterator>
> list(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { this->insert(begin(), __first, __last); }
># 530 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> list&
> operator=(const list& __x);
># 543 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 559 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> allocator_type
> get_allocator() const
> { return _Base::get_allocator(); }
>
>
>
>
>
>
> iterator
> begin()
> { return iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> const_iterator
> begin() const
> { return const_iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> iterator
> end()
> { return iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> const_iterator
> end() const
> { return const_iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> reverse_iterator
> rbegin()
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend()
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
> bool
> empty() const
> { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
>
>
> size_type
> size() const
> { return std::distance(begin(), end()); }
>
>
> size_type
> max_size() const
> { return size_type(-1); }
># 674 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> resize(size_type __new_size, value_type __x = value_type());
>
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> {
> iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
>
>
>
>
>
> const_reference
> back() const
> {
> const_iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
># 729 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> push_front(const value_type& __x)
> { this->_M_insert(begin(), __x); }
># 745 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> pop_front()
> { this->_M_erase(begin()); }
># 759 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> push_back(const value_type& __x)
> { this->_M_insert(end(), __x); }
># 774 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> pop_back()
> { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
># 789 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 805 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 823 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 848 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> iterator
> erase(iterator __position);
># 870 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> iterator
> erase(iterator __first, iterator __last)
> {
> while (__first != __last)
> __first = erase(__first);
> return __last;
> }
># 887 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> swap(list& __x)
> { _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node); }
>
>
>
>
>
>
>
> void
> clear()
> {
> _Base::_M_clear();
> _Base::_M_init();
> }
># 914 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> splice(iterator __position, list& __x)
> {
> if (!__x.empty())
> this->_M_transfer(__position, __x.begin(), __x.end());
> }
># 930 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> splice(iterator __position, list&, iterator __i)
> {
> iterator __j = __i;
> ++__j;
> if (__position == __i || __position == __j)
> return;
> this->_M_transfer(__position, __i, __j);
> }
># 952 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> splice(iterator __position, list&, iterator __first, iterator __last)
> {
> if (__first != __last)
> this->_M_transfer(__position, __first, __last);
> }
># 970 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> remove(const _Tp& __value);
># 984 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _Predicate>
> void
> remove_if(_Predicate);
># 998 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> unique();
># 1013 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _BinaryPredicate>
> void
> unique(_BinaryPredicate);
># 1026 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> void
> merge(list& __x);
># 1041 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _StrictWeakOrdering>
> void
> merge(list&, _StrictWeakOrdering);
>
>
>
>
>
>
> void
> reverse()
> { this->_M_impl._M_node.reverse(); }
>
>
>
>
>
>
>
> void
> sort();
>
>
>
>
>
>
>
> template<typename _StrictWeakOrdering>
> void
> sort(_StrictWeakOrdering);
>
> protected:
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> {
> _M_fill_assign(static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> {
> _M_fill_insert(__pos, static_cast<size_type>(__n),
> static_cast<value_type>(__x));
> }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> {
> for (; __first != __last; ++__first)
> _M_insert(__pos, *__first);
> }
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
> {
> for (; __n > 0; --__n)
> _M_insert(__pos, __x);
> }
>
>
>
> void
> _M_transfer(iterator __position, iterator __first, iterator __last)
> { __position._M_node->transfer(__first._M_node, __last._M_node); }
>
>
> void
> _M_insert(iterator __position, const value_type& __x)
> {
> _Node* __tmp = _M_create_node(__x);
> __tmp->hook(__position._M_node);
> }
>
>
> void
> _M_erase(iterator __position)
> {
> __position._M_node->unhook();
> _Node* __n = static_cast<_Node*>(__position._M_node);
> _M_get_Tp_allocator().destroy(&__n->_M_data);
> _M_put_node(__n);
> }
> };
># 1164 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> {
> typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
> const_iterator __end1 = __x.end();
> const_iterator __end2 = __y.end();
>
> const_iterator __i1 = __x.begin();
> const_iterator __i2 = __y.begin();
> while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
> {
> ++__i1;
> ++__i2;
> }
> return __i1 == __end1 && __i2 == __end2;
> }
># 1193 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
> { __x.swap(__y); }
>}
># 71 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/list" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/list.tcc" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/bits/list.tcc" 3
>namespace std
>{
> template<typename _Tp, typename _Alloc>
> void
> _List_base<_Tp, _Alloc>::
> _M_clear()
> {
> typedef _List_node<_Tp> _Node;
> _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next);
> while (__cur != &this->_M_impl._M_node)
> {
> _Node* __tmp = __cur;
> __cur = static_cast<_Node*>(__cur->_M_next);
> _M_get_Tp_allocator().destroy(&__tmp->_M_data);
> _M_put_node(__tmp);
> }
> }
>
> template<typename _Tp, typename _Alloc>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> _Node* __tmp = _M_create_node(__x);
> __tmp->hook(__position._M_node);
> return iterator(__tmp);
> }
>
> template<typename _Tp, typename _Alloc>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> erase(iterator __position)
> {
> iterator __ret = iterator(__position._M_node->_M_next);
> _M_erase(__position);
> return __ret;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> resize(size_type __new_size, value_type __x)
> {
> iterator __i = begin();
> size_type __len = 0;
> for (; __i != end() && __len < __new_size; ++__i, ++__len)
> ;
> if (__len == __new_size)
> erase(__i, end());
> else
> insert(end(), __new_size - __len, __x);
> }
>
> template<typename _Tp, typename _Alloc>
> list<_Tp, _Alloc>&
> list<_Tp, _Alloc>::
> operator=(const list& __x)
> {
> if (this != &__x)
> {
> iterator __first1 = begin();
> iterator __last1 = end();
> const_iterator __first2 = __x.begin();
> const_iterator __last2 = __x.end();
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, ++__first2)
> *__first1 = *__first2;
> if (__first2 == __last2)
> erase(__first1, __last1);
> else
> insert(__last1, __first2, __last2);
> }
> return *this;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> _M_fill_assign(size_type __n, const value_type& __val)
> {
> iterator __i = begin();
> for (; __i != end() && __n > 0; ++__i, --__n)
> *__i = __val;
> if (__n > 0)
> insert(end(), __n, __val);
> else
> erase(__i, end());
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> list<_Tp, _Alloc>::
> _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
> __false_type)
> {
> iterator __first1 = begin();
> iterator __last1 = end();
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, ++__first2)
> *__first1 = *__first2;
> if (__first2 == __last2)
> erase(__first1, __last1);
> else
> insert(__last1, __first2, __last2);
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> remove(const value_type& __value)
> {
> iterator __first = begin();
> iterator __last = end();
> while (__first != __last)
> {
> iterator __next = __first;
> ++__next;
> if (*__first == __value)
> _M_erase(__first);
> __first = __next;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> unique()
> {
> iterator __first = begin();
> iterator __last = end();
> if (__first == __last)
> return;
> iterator __next = __first;
> while (++__next != __last)
> {
> if (*__first == *__next)
> _M_erase(__next);
> else
> __first = __next;
> __next = __first;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> merge(list& __x)
> {
>
>
> if (this != &__x)
> {
> iterator __first1 = begin();
> iterator __last1 = end();
> iterator __first2 = __x.begin();
> iterator __last2 = __x.end();
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
> {
> iterator __next = __first2;
> _M_transfer(__first1, __first2, ++__next);
> __first2 = __next;
> }
> else
> ++__first1;
> if (__first2 != __last2)
> _M_transfer(__last1, __first2, __last2);
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> sort()
> {
>
> if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
> && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
> {
> list __carry;
> list __tmp[64];
> list * __fill = &__tmp[0];
> list * __counter;
>
> do
> {
> __carry.splice(__carry.begin(), *this, begin());
>
> for(__counter = &__tmp[0];
> __counter != __fill && !__counter->empty();
> ++__counter)
> {
> __counter->merge(__carry);
> __carry.swap(*__counter);
> }
> __carry.swap(*__counter);
> if (__counter == __fill)
> ++__fill;
> }
> while ( !empty() );
>
> for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
> __counter->merge(*(__counter - 1));
> swap( *(__fill - 1) );
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _Predicate>
> void
> list<_Tp, _Alloc>::
> remove_if(_Predicate __pred)
> {
> iterator __first = begin();
> iterator __last = end();
> while (__first != __last)
> {
> iterator __next = __first;
> ++__next;
> if (__pred(*__first))
> _M_erase(__first);
> __first = __next;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _BinaryPredicate>
> void
> list<_Tp, _Alloc>::
> unique(_BinaryPredicate __binary_pred)
> {
> iterator __first = begin();
> iterator __last = end();
> if (__first == __last)
> return;
> iterator __next = __first;
> while (++__next != __last)
> {
> if (__binary_pred(*__first, *__next))
> _M_erase(__next);
> else
> __first = __next;
> __next = __first;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _StrictWeakOrdering>
> void
> list<_Tp, _Alloc>::
> merge(list& __x, _StrictWeakOrdering __comp)
> {
>
>
> if (this != &__x)
> {
> iterator __first1 = begin();
> iterator __last1 = end();
> iterator __first2 = __x.begin();
> iterator __last2 = __x.end();
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
> {
> iterator __next = __first2;
> _M_transfer(__first1, __first2, ++__next);
> __first2 = __next;
> }
> else
> ++__first1;
> if (__first2 != __last2)
> _M_transfer(__last1, __first2, __last2);
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _StrictWeakOrdering>
> void
> list<_Tp, _Alloc>::
> sort(_StrictWeakOrdering __comp)
> {
>
> if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
> && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
> {
> list __carry;
> list __tmp[64];
> list * __fill = &__tmp[0];
> list * __counter;
>
> do
> {
> __carry.splice(__carry.begin(), *this, begin());
>
> for(__counter = &__tmp[0];
> __counter != __fill && !__counter->empty();
> ++__counter)
> {
> __counter->merge(__carry, __comp);
> __carry.swap(*__counter);
> }
> __carry.swap(*__counter);
> if (__counter == __fill)
> ++__fill;
> }
> while ( !empty() );
>
> for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
> __counter->merge(*(__counter - 1), __comp);
> swap(*(__fill - 1));
> }
> }
>}
># 74 "/usr/lib/gcc/i386-redhat-linux/4.1.1/../../../../include/c++/4.1.1/list" 2 3
># 25 "/usr/local/include/mtl/matrix.h" 2 3
>
>
># 1 "/usr/local/include/mtl/meta_equal.h" 1 3
># 28 "/usr/local/include/mtl/meta_equal.h" 3
>template<int n1, int n2>
>struct EQUAL
>{
> enum {RET= n1==n2 ? 1:0};
>};
># 28 "/usr/local/include/mtl/matrix.h" 2 3
>
>
>
># 1 "/usr/local/include/mtl/compressed1D.h" 1 3
># 24 "/usr/local/include/mtl/compressed1D.h" 3
># 1 "/usr/local/include/mtl/entry.h" 1 3
># 22 "/usr/local/include/mtl/entry.h" 3
>namespace mtl {
># 31 "/usr/local/include/mtl/entry.h" 3
>template <class T>
>struct entry1 {
>
>
>
>
> typedef entry1<T> self;
>
> typedef T value_type;
>
> int index;
> mutable value_type value;
>
> inline entry1() : index(-1) { }
>
> inline entry1(int i, value_type v = value_type()) : index(i), value(v) { }
>
> inline entry1(const self& x) : index(x.index), value(x.value) { }
>
> inline self& operator=(const self& x) {
> index = x.index;
> value = x.value;
> return *this;
> }
>
> inline bool operator < (const entry1& e) const {
> return index < e.index; }
>
> inline bool operator == (const entry1& e) const {
> return index == e.index; }
>
> inline bool operator != (const entry1& e) const {
> return index != e.index; }
>};
>
>template <class T>
>std::ostream& operator<<(std::ostream& os, const entry1<T>& e)
>{
> os << "(" << e.index << "," << e.value << ") ";
> return os;
>}
>
>
>
>template <class OneD>
>class elt_ref {
> typedef elt_ref self;
>public:
> typedef typename OneD::value_type value_type;
>
> inline elt_ref() : vec(OneD()), i(-1) { }
>
> inline elt_ref(OneD& m, int i_)
> : vec(m), i(i_) {
> iter = vec.find(i);
> if (iter != vec.end()) {
> if (iter.index() == i)
> val = *iter;
> else
> val = value_type();
> } else
> val = value_type();
> }
>
> inline operator value_type() const {
> return val;
> }
>
> inline value_type operator=(value_type v) {
> if (iter != vec.end() && iter.index() == i) {
> *iter = val = v;
> } else {
> val = v;
> iter = vec.insert(iter, i, v);
> }
> return val;
> }
>
> inline value_type operator+=(value_type v) {
> if (iter != vec.end() && iter.index() == i) {
> *iter = val += v;
> } else {
> val = v;
> iter = vec.insert(iter, i, v);
> }
> return val;
> }
>
> inline value_type operator*=(value_type v) {
> if (iter != vec.end() && iter.index() == i)
> *iter = val *= v;
> return val;
> }
>
>
> inline value_type operator/=(const self& v) {
> if (iter != vec.end() && iter.index() == i)
> *iter = val /= v.val;
> return val;
> }
>
> inline value_type operator/=(value_type v) {
> if (iter != vec.end() && iter.index() == i)
> *iter = val /= val;
> return val;
> }
>
> inline value_type operator-=(value_type v) {
> if (iter != vec.end() && iter.index() == i)
> *iter = val -= v;
> else {
> val = -v;
> iter = vec.insert(iter, i, val);
> }
> return val;
> }
>
> inline value_type operator=(const self& a) {
> if (iter != vec.end() && iter.index() == i)
> *iter = val = a.val;
> else
> iter = vec.insert(iter, i, a.val);
> return val;
> }
>
>
> OneD vec;
>
>
>
>
> typename OneD::iterator iter;
> int i;
> value_type val;
>};
>
>
>
>
>
>template <class OneD>
>class const_elt_ref {
> typedef const_elt_ref self;
>public:
> typedef typename OneD::value_type value_type;
>
>
> template <class EltRef>
> inline const_elt_ref(const EltRef& elt) {
> typename OneD::const_iterator iter = elt.vec.find(elt.i);
> if (iter != elt.vec.end()) {
> if (iter.index() == elt.i)
> val = *iter;
> else
> val = value_type();
> } else
> val = value_type();
> }
>
> inline const_elt_ref(const OneD& vec, int i) {
> typename OneD::const_iterator iter = vec.find(i);
> if (iter != vec.end()) {
> if (iter.index() == i)
> val = *iter;
> else
> val = value_type();
> } else
> val = value_type();
> }
>
> inline operator value_type() const { return val; }
>
>protected:
> value_type val;
>};
>
>
>
>
>template <class T>
>std::ostream& operator<<(std::ostream& os, const elt_ref<T>& er) {
> typedef typename elt_ref<T>::value_type value_type;
> os << value_type(er);
> return os;
>}
>
>template <class OneD>
>std::ostream& operator<<(std::ostream& os, const const_elt_ref<OneD>& er) {
> typedef typename const_elt_ref<OneD>::value_type value_type;
> os << value_type(er);
> return os;
>}
># 241 "/usr/local/include/mtl/entry.h" 3
>template <class T, class U> T operator + (const T& a, const elt_ref& e) { return a + T(e); } template <class T, class U> T operator + (const elt_ref& e, const T& a) { return T(e) + a; } template <class V, class U> typename elt_ref<V>::value_type operator + (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) + T(e); }
>template <class T, class U> T operator - (const T& a, const elt_ref& e) { return a - T(e); } template <class T, class U> T operator - (const elt_ref& e, const T& a) { return T(e) - a; } template <class V, class U> typename elt_ref<V>::value_type operator - (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) - T(e); }
>template <class T, class U> T operator * (const T& a, const elt_ref& e) { return a * T(e); } template <class T, class U> T operator * (const elt_ref& e, const T& a) { return T(e) * a; } template <class V, class U> typename elt_ref<V>::value_type operator * (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) * T(e); }
>template <class T, class U> T operator / (const T& a, const elt_ref& e) { return a / T(e); } template <class T, class U> T operator / (const elt_ref& e, const T& a) { return T(e) / a; } template <class V, class U> typename elt_ref<V>::value_type operator / (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) / T(e); }
># 261 "/usr/local/include/mtl/entry.h" 3
>template <class T, class U> bool operator == (const T& a, const elt_ref& e) { return a == T(e); } template <class T, class U> bool operator == (const elt_ref& e, const T& a) { return T(e) == a; } template <class V, class U> bool operator == (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) == T(e); }
>template <class T, class U> bool operator != (const T& a, const elt_ref& e) { return a != T(e); } template <class T, class U> bool operator != (const elt_ref& e, const T& a) { return T(e) != a; } template <class V, class U> bool operator != (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) != T(e); }
>template <class T, class U> bool operator < (const T& a, const elt_ref& e) { return a < T(e); } template <class T, class U> bool operator < (const elt_ref& e, const T& a) { return T(e) < a; } template <class V, class U> bool operator < (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) < T(e); }
>template <class T, class U> bool operator > (const T& a, const elt_ref& e) { return a > T(e); } template <class T, class U> bool operator > (const elt_ref& e, const T& a) { return T(e) > a; } template <class V, class U> bool operator > (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) > T(e); }
>template <class T, class U> bool operator <= (const T& a, const elt_ref& e) { return a <= T(e); } template <class T, class U> bool operator <= (const elt_ref& e, const T& a) { return T(e) <= a; } template <class V, class U> bool operator <= (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) <= T(e); }
>template <class T, class U> bool operator >= (const T& a, const elt_ref& e) { return a >= T(e); } template <class T, class U> bool operator >= (const elt_ref& e, const T& a) { return T(e) >= a; } template <class V, class U> bool operator >= (const elt_ref<V>& f, const elt_ref& e) { typedef typename elt_ref<V>::value_type T; return T(f) >= T(e); }
># 284 "/usr/local/include/mtl/entry.h" 3
>template <class T, class U> T operator + (const T& a, const const_elt_ref& e) { return a + T(e); } template <class T, class U> T operator + (const const_elt_ref& e, const T& a) { return T(e) + a; } template <class V, class U> typename const_elt_ref<V>::value_type operator + (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) + T(e); }
>template <class T, class U> T operator - (const T& a, const const_elt_ref& e) { return a - T(e); } template <class T, class U> T operator - (const const_elt_ref& e, const T& a) { return T(e) - a; } template <class V, class U> typename const_elt_ref<V>::value_type operator - (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) - T(e); }
>template <class T, class U> T operator * (const T& a, const const_elt_ref& e) { return a * T(e); } template <class T, class U> T operator * (const const_elt_ref& e, const T& a) { return T(e) * a; } template <class V, class U> typename const_elt_ref<V>::value_type operator * (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) * T(e); }
>template <class T, class U> T operator / (const T& a, const const_elt_ref& e) { return a / T(e); } template <class T, class U> T operator / (const const_elt_ref& e, const T& a) { return T(e) / a; } template <class V, class U> typename const_elt_ref<V>::value_type operator / (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) / T(e); }
># 306 "/usr/local/include/mtl/entry.h" 3
>template <class T, class U> bool operator == (const T& a, const const_elt_ref& e) { return a == T(e); } template <class T, class U> bool operator == (const const_elt_ref& e, const T& a) { return T(e) == a; } template <class V, class U> bool operator == (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) == T(e); }
>template <class T, class U> bool operator != (const T& a, const const_elt_ref& e) { return a != T(e); } template <class T, class U> bool operator != (const const_elt_ref& e, const T& a) { return T(e) != a; } template <class V, class U> bool operator != (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) != T(e); }
>template <class T, class U> bool operator < (const T& a, const const_elt_ref& e) { return a < T(e); } template <class T, class U> bool operator < (const const_elt_ref& e, const T& a) { return T(e) < a; } template <class V, class U> bool operator < (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) < T(e); }
>template <class T, class U> bool operator > (const T& a, const const_elt_ref& e) { return a > T(e); } template <class T, class U> bool operator > (const const_elt_ref& e, const T& a) { return T(e) > a; } template <class V, class U> bool operator > (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) > T(e); }
>template <class T, class U> bool operator <= (const T& a, const const_elt_ref& e) { return a <= T(e); } template <class T, class U> bool operator <= (const const_elt_ref& e, const T& a) { return T(e) <= a; } template <class V, class U> bool operator <= (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) <= T(e); }
>template <class T, class U> bool operator >= (const T& a, const const_elt_ref& e) { return a >= T(e); } template <class T, class U> bool operator >= (const const_elt_ref& e, const T& a) { return T(e) >= a; } template <class V, class U> bool operator >= (const const_elt_ref<V>& f, const const_elt_ref& e) { typedef typename const_elt_ref<V>::value_type T; return T(f) >= T(e); }
>
>
>
>
>
>
>
>template <class T>
>struct entry2 {
> typedef entry2<T> self;
> typedef T value_type;
>
> int row, col;
> value_type value;
>
> inline entry2() : row(-1), col(-1), value(0.0) { }
> inline entry2(int r, int c, value_type v = value_type())
> : row(r), col(c), value(v) { }
> inline entry2(const self& x) : row(x.row), col(x.col), value(x.value) { }
> inline self& operator =(const self& x) {
> row = x.row;
> col = x.col;
> value = x.value;
> return *this;
> }
> inline bool operator == (const entry2& e) const {
> return row == e.row && col == e.col; }
>};
>
>}
># 25 "/usr/local/include/mtl/compressed1D.h" 2 3
># 1 "/usr/local/include/mtl/compressed_iter.h" 1 3
># 15 "/usr/local/include/mtl/compressed_iter.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 16 "/usr/local/include/mtl/compressed_iter.h" 2 3
>
>
>
>namespace mtl {
># 30 "/usr/local/include/mtl/compressed_iter.h" 3
>template <int isConst, class Value, class Index, int IND_OFFSET>
>class compressed_iter {
> typedef compressed_iter self;
> typedef Value values_t;
> typedef typename values_t::iterator value_iterator;
> typedef typename values_t::const_iterator value_const_iterator;
> typedef typename IF<isConst, value_const_iterator, value_iterator>::RET value_iter_t;
> typedef Index indices_t;
> typedef typename indices_t::iterator index_iterator;
> typedef typename indices_t::const_iterator index_const_iterator;
> typedef typename IF<isConst, index_const_iterator, index_iterator>::RET index_iter_t;
>public:
>
>
>
> typedef typename std::iterator_traits<value_iterator>::iterator_category iterator_category;
>
> typedef typename Value::value_type value_type;
> typedef int difference_type;
> typedef difference_type distance_type;
> typedef typename IF<isConst, const value_type*,value_type*>::RET pointer;
> typedef typename IF<isConst, const value_type&, value_type&>::RET reference;
> typedef const value_type& const_reference;
>
> inline compressed_iter() : pos (0) { }
>
> inline compressed_iter(const self& x)
> : index_iter_(x.index_iter_), value_iter_(x.value_iter_), pos(x.pos) { }
>
> struct bogus { };
>
> typedef typename IF<isConst, compressed_iter<0,Value,Index,IND_OFFSET>,
> bogus>::RET NonConst;
>
> inline compressed_iter(const NonConst& x)
> : index_iter_(x.index_iter_), value_iter_(x.value_iter_), pos(x.pos) { }
>
> inline self& operator=(const self& x) {
> index_iter_ = x.index_iter_;
> value_iter_ = x.value_iter_;
> pos = x.pos;
> return *this;
> }
>
> inline compressed_iter(value_iter_t vals, index_iter_t inds, int p)
> : index_iter_(inds), value_iter_(vals), pos(p) { }
>
> inline int index() const {
> return index_iter_[pos] + IND_OFFSET;
> }
> inline void set_index(int i) {
> index_iter_[pos] = i;
> }
>
> inline reference operator*() const { return value_iter_[pos]; }
>
> inline self& operator++() { ++pos; return *this; }
> inline self operator++(int) {
> self tmp = *this; ++pos; return tmp;
> }
> inline self& operator--() { --pos; return *this; }
> inline self operator--(int) {
> self tmp = *this; --pos; return tmp;
> }
> inline self& operator+=(int n) { pos += n; return *this; }
> inline self& operator-=(int n) { pos -= n; return *this; }
>
> inline self operator+(int n) {
> return self(value_iter_, index_iter_, pos + n);
> }
> inline self operator-(int n) const {
> return self(value_iter_, index_iter_, pos - n);
> }
> inline int operator-(const self& x) const {
> return pos - x.pos;
> }
>
> inline bool operator != (const self& y) const {
> return pos != y.pos;
> }
> inline bool operator < (const self& y) const {
> return pos < y.pos;
> }
> inline bool operator == (const self& y) const {
> return pos == y.pos;
> }
>
> inline index_iter_t index_iter() const { return index_iter_ + pos; }
> inline value_iter_t value_iter() const { return value_iter_ + pos; }
>
> index_iter_t index_iter_;
> value_iter_t value_iter_;
> int pos;
>};
>
>
>
>}
># 26 "/usr/local/include/mtl/compressed1D.h" 2 3
>
>
>
>
>
>
>
>namespace mtl {
>
>using std::lower_bound;
>using std::find;
># 73 "/usr/local/include/mtl/compressed1D.h" 3
>template <class T, class SizeType = int, int IND_OFFSET = index_from_zero>
>class compressed1D {
>
> typedef std::vector<T> values_vec;
> typedef std::vector<SizeType> indices_vec;
> typedef indices_vec indices_t;
> typedef values_vec values_t;
>
> typedef refcnt_ptr< values_vec > values_ptr;
> typedef refcnt_ptr< indices_vec > indices_ptr;
>
> typedef compressed1D<T,SizeType,IND_OFFSET> self;
>
> typedef typename indices_vec::iterator index_iterator;
> typedef typename values_vec::iterator value_iterator;
> typedef typename indices_vec::const_iterator index_const_iterator;
> typedef typename values_vec::const_iterator value_const_iterator;
>
> friend class elt_ref<self>;
> friend class const_elt_ref<self>;
>
>public:
>
>
> enum { N = 0 };
>
>
> typedef sparse_tag sparsity;
>
> typedef oned_tag dimension;
>
> typedef scaled1D< self > scaled_type;
>
> typedef typename values_t::value_type value_type;
>
>
>
>
> typedef typename values_t::pointer pointer;
>
>
> typedef SizeType size_type;
>
> typedef typename values_t::difference_type difference_type;
>
> typedef elt_ref<self> reference;
>
> typedef const_elt_ref<self> const_reference;
>
> typedef compressed_iter<0,values_vec, indices_vec,IND_OFFSET> iterator;
>
> typedef compressed_iter<1,values_vec, indices_vec,IND_OFFSET> const_iterator;
>
> typedef reverse_iter<iterator> reverse_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
> typedef const indices_vec& IndexArrayRef;
>
> typedef const indices_t IndexArray;
>
>
> typedef self subrange_type;
>
>
>
>
>
>
> inline compressed1D()
> : values(new values_t(0)),
> indices(new indices_t(0)),
> size_(0) { }
>
>
> inline compressed1D(size_type n)
> : values(new values_t(0)),
> indices(new indices_t(0)),
> size_(n) { }
>
>
> inline compressed1D(const self& x)
> : values(x.values), indices(x.indices), size_(x.size_) { }
>
>
> template <class IndexIter>
> inline compressed1D(IndexIter first, IndexIter last, size_type n)
> : values(new values_t(n)),
> indices(new indices_t(n)),
> size_(n)
> {
> std::copy(first, last, indices->begin());
> }
>
>
> inline self& operator=(const self& x) {
> values = x.values;
> indices = x.indices;
> size_ = x.size_;
> return *this;
> }
># 182 "/usr/local/include/mtl/compressed1D.h" 3
> inline iterator begin() {
> return iterator(values->begin(), indices->begin(), 0);
> }
>
>
> inline iterator end() {
> return iterator(values->begin(), indices->begin(), indices->size());
> }
>
>
> inline const_iterator begin() const {
> return const_iterator(values->begin(), indices->begin(), 0);
> }
>
>
> inline const_iterator end() const {
> return const_iterator(values->begin(), indices->begin(), indices->size());
> }
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
>
>
> inline reference operator[](size_type i) {
> ;
> return reference(*this, i);
> }
>
> inline const_reference operator[](size_type i) const {
> ;
> return const_reference(*this, i);
> }
>
>
> value_type& get_ref(size_type i) {
> iterator iter = find(i);
> if ( iter != end() ) {
> if ( iter.index() != i )
> iter = insert(iter, i, T(0));
> } else
> iter = insert(iter, i, T(0));
>
> return *iter;
> }
># 254 "/usr/local/include/mtl/compressed1D.h" 3
> inline iterator insert(size_type i, const T& val) {
> ;
> index_iterator index_iter = lower_bound(indices->begin(),
> indices->end(),
> i - IND_OFFSET);
> index_iter = indices->insert(index_iter, i - IND_OFFSET);
> size_type n = index_iter - indices->begin();
> value_iterator val_iter = values->insert(values->begin() + n, val);
> return iterator(index_iter, val_iter);
> }
>
>
>
> inline void push_back(size_type i, const T& val) {
> ;
> values->push_back(val);
> indices->push_back(i);
> }
>
>
> inline void clear() { indices->clear(); values->clear(); }
>
> inline size_type size() const { return size_; }
>
> inline size_type nnz() const { return values->size(); }
>
> inline void resize(size_type n) {
> size_ = n;
> }
>
> inline void reserve(size_type n) {
> values->reserve(n);
> indices->reserve(n);
> }
>
> inline IndexArrayRef nz_struct() const {
> return *indices;
> }
>
>
> inline IndexArrayRef nz_struct() {
> return *indices;
> }
>
>protected:
>
> inline iterator find(size_type i) {
> index_iterator iter = lower_bound(indices->begin(), indices->end(),
> i - IND_OFFSET);
> size_type n = iter - indices->begin();
> return iterator(values->begin(), indices->begin(), n);
> }
>
> inline const_iterator find(size_type i) const {
> index_const_iterator iter = lower_bound(indices->begin(), indices->end(),
> i - IND_OFFSET);
> size_type n = iter - indices->begin();
> return const_iterator(values->begin(), indices->begin(), n);
> }
>
> inline iterator insert(iterator iter, size_type i, T v) {
> index_iterator ind = indices->insert(iter.index_iter(),
> i - IND_OFFSET);
> values->insert(iter.value_iter(), v);
> size_type n = ind - indices->begin();
> return iterator(values->begin(), indices->begin(), n);
> }
>
>
>protected:
> values_ptr values;
> indices_ptr indices;
> size_type size_;
>};
>
>}
># 32 "/usr/local/include/mtl/matrix.h" 2 3
>
># 1 "/usr/local/include/mtl/matrix_implementation.h" 1 3
># 17 "/usr/local/include/mtl/matrix_implementation.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 18 "/usr/local/include/mtl/matrix_implementation.h" 2 3
>
>
>
># 1 "/usr/local/include/mtl/oned_part.h" 1 3
># 28 "/usr/local/include/mtl/oned_part.h" 3
>namespace mtl {
>
>
>template <class Vector, class VecRef, class Indexer>
>class oned_part {
>public:
> typedef typename Vector::iterator base_iterator;
> typedef typename Vector::const_iterator const_base_iterator;
> typedef oned_part self;
> enum { N = Vector::N };
>
>
> typedef typename Vector::value_type value_type;
> typedef typename Vector::reference reference;
> typedef typename Vector::const_reference const_reference;
> typedef typename Vector::pointer pointer;
> typedef typename Vector::size_type size_type;
> typedef typename Vector::difference_type difference_type;
> typedef typename Vector::subrange_type inner_subrange;
> typedef oned_part<inner_subrange, inner_subrange, Indexer> subrange_type;
>
> typedef typename Vector::sparsity sparsity;
> typedef typename Vector::IndexArrayRef IndexArrayRef;
> typedef typename Vector::IndexArray IndexArray;
> typedef typename Vector::dimension dimension;
> typedef scaled1D< self > scaled_type;
>
>
>
> template <int isConst>
> class __iterator {
> typedef __iterator self;
> typedef typename IF<isConst,const_base_iterator,base_iterator>::RET Iterator;
> public:
>
> typedef typename std::iterator_traits<Iterator>::difference_type
> difference_type;
>
>
>
>
>
> typedef typename std::iterator_traits<Iterator>::value_type value_type;
> typedef typename std::iterator_traits<Iterator>::iterator_category
> iterator_category;
>
> typedef typename std::iterator_traits<Iterator>::pointer pointer;
> typedef typename std::iterator_traits<Iterator>::reference reference;
>
>
>
>
>
> typedef difference_type Distance;
> typedef Iterator iterator_type;
>
> inline __iterator() { }
>
> inline __iterator(const Iterator& x, Indexer ind)
> : iter(x), indexer(ind) { }
>
> inline __iterator(const self& x)
> : iter(x.iter), indexer(x.indexer) { }
>
> inline self& operator=(const self& x) {
> iter = x.iter; indexer = x.indexer; return *this;
> }
>
> inline operator Iterator() { return iter; }
>
> inline Iterator base() const { return iter; }
>
> inline reference operator*() const { return *iter; }
>
> inline self& operator++() { ++iter; return *this; }
>
> inline self operator++(int) {
> self tmp = (*this);
> ++(*this);
> return tmp;
> }
>
> inline self& operator--() { --iter; return *this; }
>
> inline self operator--(int) {
> self tmp = (*this);
> --(*this);
> return tmp;
> }
>
> inline self operator+(Distance n) const {
> self tmp = (*this);
> tmp += n;
> return tmp;
> }
>
> inline self& operator+=(Distance n) {
> iter += n; return (*this);
> }
>
> inline self operator-(Distance n) const {
> self tmp = (*this);
> tmp -= n;
> return tmp;
> }
>
> inline self& operator-=(Distance n) {
> iter -= n; return (*this);
> }
>
> inline reference operator[](Distance n) const {
> self tmp = (*this);
> return *(tmp += n);
> }
>
> inline Distance operator-(const self& y) const {
> return iter - y.iter;
> }
>
> inline bool operator==(const self& y) const {
> return iter == y.iter;
> }
>
> inline bool operator!=(const self& y) const {
> return iter != y.iter;
> }
>
> inline bool operator<(const self& y) const {
> return iter < y.iter;
> }
>
> inline size_type row() const { return indexer.row(iter); }
> inline size_type column() const { return indexer.column(iter); }
> inline size_type index() const { return indexer.minor(iter); }
> protected:
> Iterator iter;
> Indexer indexer;
> };
>
> typedef __iterator<0> iterator;
> typedef __iterator<1> const_iterator;
>
> typedef reverse_iter< iterator > reverse_iterator;
> typedef reverse_iter< const_iterator > const_reverse_iterator;
>
>
>
> inline oned_part(VecRef v, Indexer ind) : vec(v), indexer(ind) { }
>
> inline oned_part(const oned_part& x) : vec(x.vec), indexer(x.indexer) { }
>
>
> template <class OtherOneD>
> inline oned_part(const OtherOneD& x) : vec(x.vec), indexer(x.indexer) { }
>
>
> inline oned_part& operator=(const oned_part& x) {
> vec = x.vec; indexer = x.indexer; return *this;
> }
>
> template <class OtherOneD>
> inline oned_part& operator=(const OtherOneD& x) {
> vec = x.vec; indexer = x.indexer; return *this;
> }
>
> inline iterator begin() {
> return iterator(indexer.begin(vec.begin()), indexer);
> }
> inline iterator end() {
> return iterator(vec.end(), indexer);
> }
> inline const_iterator begin() const {
> return const_iterator(indexer.begin(vec.begin()), indexer);
> }
> inline const_iterator end() const {
> return const_iterator(vec.end(), indexer);
> }
>
> inline reverse_iterator rbegin() { return reverse_iterator(end()); }
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
> inline reference operator[](size_type n) {
> return vec[indexer.at(n)];
> }
> inline const_reference operator[](size_type n) const {
> return vec[indexer.at(n)];
> }
>
>
> inline value_type& get_ref(size_type j) {
> return vec.get_ref(j);
> }
>
> inline subrange_type operator()(size_type i, size_type j) const {
> return subrange_type(vec(indexer.at(i), indexer.at(j)), indexer);
> }
>
> inline size_type size() const { return vec.size(); }
>
>
> inline void reserve(size_type i) {
> vec.reserve(i);
> }
>
> inline void resize(size_type i) {
> vec.resize(i);
> }
>
> inline void clear() { vec.clear(); }
> inline void push_back(size_type i, const value_type& t) {
> vec.push_back(i, t);
> }
>
> inline size_type nnz() const { return vec.nnz(); }
>
> inline IndexArrayRef nz_struct() const { return vec.nz_struct(); }
>
>
>
>
>
>
> VecRef vec;
> Indexer indexer;
>};
>
>}
># 22 "/usr/local/include/mtl/matrix_implementation.h" 2 3
># 1 "/usr/local/include/mtl/scaled2D.h" 1 3
># 20 "/usr/local/include/mtl/scaled2D.h" 3
>namespace mtl {
>
>
>
>template <class twod_iter, class T, class ValType, class Ref>
>class scaled2D_iter {
> typedef scaled2D_iter<twod_iter, T, ValType, Ref> self;
>public:
> typedef ValType value_type;
> typedef Ref reference;
> typedef value_type* pointer;
>
>
>
>
> typedef typename std::iterator_traits<twod_iter>::difference_type difference_type;
>
> typedef typename std::iterator_traits<twod_iter>::iterator_category iterator_category;
> typedef typename ValType::size_type size_type;
>
> inline scaled2D_iter() { }
> inline scaled2D_iter(const twod_iter& x, const T& a)
> : iter(x), alpha(a) {}
> inline scaled2D_iter(const self& x) : iter(x.iter), alpha(x.alpha) { }
> inline self& operator=(const self& x) {
> iter = x.iter;
> alpha = x.alpha;
> return *this;
> }
>
> inline reference operator*() const { return reference(*iter, alpha); }
> inline reference operator[](size_type n) const {
> return reference(iter[n], alpha);
> }
>
> inline self& operator++() { ++iter; return *this; }
> inline self& operator+=(size_type n) { iter += n; return *this; }
> inline self operator++(int) { self t = *this; ++(*this); return t; }
> inline self& operator--() { --iter; return *this; }
> inline self& operator-=(size_type n) { iter -= n; return *this; }
> inline self operator--(int) { self t = *this; --(*this); return t; }
> inline bool operator!=(const self& x) const { return iter != x.iter; }
> inline bool operator==(const self& x) const { return iter == x.iter; }
> inline bool operator<(const self& x) const { return iter < x.iter; }
> inline difference_type operator-(const self& x) {
> return iter - x.iter; }
> inline size_type index() const { return iter.index(); }
>
>protected:
> twod_iter iter;
> T alpha;
>};
>
>template <class TwoD, class T>
>struct gen_scaled2D;
># 84 "/usr/local/include/mtl/scaled2D.h" 3
>template <class TwoD, class T>
>class scaled2D {
> typedef scaled2D<TwoD,T> self;
>public:
>
> template <class SubMatrix>
> struct partitioned {
> typedef scaled2D< TwoD, SubMatrix> type;
> typedef gen_scaled2D<TwoD, SubMatrix> generator;
> };
>
>
>
> enum { M = TwoD::M, N = TwoD::N };
>
>
> typedef typename TwoD::size_type size_type;
>
>
> typedef scaled1D<typename TwoD::value_type> value_type;
>
> typedef scaled1D<typename TwoD::value_type> reference;
>
> typedef const scaled1D<typename TwoD::value_type> const_reference;
>
> typedef scaled2D_iter<typename TwoD::iterator, T,
> value_type, reference> iterator;
>
> typedef scaled2D_iter<typename TwoD::const_iterator, T,
> value_type, reference> const_iterator;
>
> typedef reverse_iter< scaled2D_iter<typename TwoD::reverse_iterator, T,
> value_type, reference> > reverse_iterator;
>
> typedef reverse_iter< scaled2D_iter<typename TwoD::const_reverse_iterator, T,
> value_type, reference> > const_reverse_iterator;
>
> typedef typename TwoD::sparsity sparsity;
>
> typedef typename TwoD::strideability strideability;
>
> typedef typename TwoD::storage_loc storage_loc;
>
> typedef scaled2D< typename TwoD::transpose_type, T > transpose_type;
>
>
>
>
> inline scaled2D() : alpha(0) { }
>
> inline scaled2D(const TwoD& x, const T& a) : twod(x), alpha(a) { }
># 143 "/usr/local/include/mtl/scaled2D.h" 3
> inline const_iterator begin() const {
> return const_iterator(twod.begin(), alpha);
> }
>
> inline const_iterator end() const {
> return const_iterator(twod.end(), alpha);
> }
>
>
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
>
> inline reference operator[](int i) const {
> return reference(twod[i], alpha);
> }
>
> inline T operator()(int i, int j) const {
> return twod(i, j) * alpha;
> }
>
>
>
>
>
> inline int major() const { return twod.major(); }
>
> inline int minor() const { return twod.minor(); }
>
> inline size_type nnz() const { return twod.nnz(); }
># 190 "/usr/local/include/mtl/scaled2D.h" 3
>protected:
> TwoD twod;
> T alpha;
>};
>
>
>
>template <class TwoD, class T>
>struct gen_scaled2D {
> typedef gen_scaled2D<typename TwoD::transpose_type, T> transpose_type;
> typedef gen_scaled2D<typename TwoD::submatrix_type, T> submatrix_type;
> typedef gen_scaled2D<typename TwoD::banded_view_type, T> banded_view_type;
>
> typedef scaled2D<TwoD, T> type;
># 212 "/usr/local/include/mtl/scaled2D.h" 3
>};
>
>
>}
># 23 "/usr/local/include/mtl/matrix_implementation.h" 2 3
>
>
># 1 "/usr/local/include/mtl/dimension.h" 1 3
>
>
>
>
>
>namespace mtl {
># 18 "/usr/local/include/mtl/dimension.h" 3
>template <class sizet, int MM = 0, int NN = 0>
>class dimension {
> typedef dimension<sizet, MM, NN> self;
>public:
> typedef dimension<sizet, NN, MM> transpose_type;
> typedef sizet size_type;
> enum { M = MM, N = NN };
> inline dimension() : m(0), n(0) { }
> inline dimension(const self& x) : m(x.m), n(x.n) { }
> template <class ST>
> inline dimension(const std::pair<ST,ST>& x) : m(x.first), n(x.second) { }
>
>
>
> template <class S, int MMM, int NNN>
> inline dimension(const dimension<S, MMM, NNN>& x) : m(x.m), n(x.n) {}
>
> inline dimension(size_type m_, size_type n_) : m(m_), n(n_) { }
> inline dimension& operator=(const dimension& x) {
> m = x.m; n = x.n; return *this; }
> inline size_type first() const { return M ? M : m; }
> inline size_type second() const { return N ? N : n; }
> inline bool is_static() const { return M != 0; }
> inline transpose_type transpose() const { return transpose_type(n, m); }
>
> size_type m, n;
>};
>
>}
># 26 "/usr/local/include/mtl/matrix_implementation.h" 2 3
># 1 "/usr/local/include/mtl/matrix_stream.h" 1 3
>
>
>
>
>
>
>
>namespace mtl {
>
>template <class T>
>class matrix_market_stream;
>
>template <class T>
>class harwell_boeing_stream;
>
>}
># 27 "/usr/local/include/mtl/matrix_implementation.h" 2 3
># 1 "/usr/local/include/mtl/linalg_vec.h" 1 3
># 28 "/usr/local/include/mtl/linalg_vec.h" 3
># 1 "/usr/local/include/mtl/external_vector.h" 1 3
>
>
>
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 5 "/usr/local/include/mtl/external_vector.h" 2 3
>
>
>namespace mtl {
>
>
>template <class T, int NN = 0, class SizeT = size_t, class DiffT = ptrdiff_t>
>class external_vector {
> typedef external_vector<T, NN> self;
>public:
>
> enum { N = NN };
>
>
> typedef T* iterator;
> typedef const T* const_iterator;
>
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>
>
>
>
> typedef T value_type;
> typedef T& reference;
> typedef const T& const_reference;
> typedef T* pointer;
> typedef SizeT size_type;
> typedef DiffT difference_type;
>
>private:
>
>
> inline external_vector() : data_(0), size_(0) { }
>
>
> inline external_vector(const self& x) : data_(0), size_(0) { }
>
>public:
>
>
> inline external_vector(value_type* data, size_type n = N)
> : data_(data), size_(n) { }
>
> inline ~external_vector() { }
>
>
> inline self& operator=(const self& x) {
> ;
> std::copy(x.begin(), x.end(), this->begin());
> }
>
>
> inline iterator begin() { return iterator(data_); }
> inline iterator end() { return iterator(data_ + size()); }
> inline const_iterator begin() const {
> return const_iterator(data_); }
> inline const_iterator end() const {
> return const_iterator(data_ + size()); }
>
> inline reverse_iterator rbegin() { return reverse_iterator(end()); }
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end()); }
> inline const_reverse_iterator rend() const{
> return const_reverse_iterator(begin()); }
>
>
> inline reference operator[](int n) { return data_[n]; }
> inline const_reference operator[](int n) const {
> return data_[n]; }
>
>
> inline size_type size() const { return N ? N : size_; }
> inline void set_size(size_type n) { size_ = n; }
>
>
> inline pointer data() const { return data_; }
> inline void set_data(pointer d) { data_ = d; }
>
>protected:
>
> pointer data_;
> size_type size_;
>
>};
>
>
>}
># 29 "/usr/local/include/mtl/linalg_vec.h" 2 3
>
>
>namespace mtl {
># 45 "/usr/local/include/mtl/linalg_vec.h" 3
>template <class RepType, class RepPtr = RepType*, int NN = 0>
>class linalg_vec {
>public:
> typedef linalg_vec self;
> typedef RepType rep_type;
> typedef RepPtr rep_ptr;
>
> enum { N = NN };
>
>
>
>
> typedef oned_tag dimension;
>
>
> typedef dense_tag sparsity;
>
>
>
> typedef scaled1D< self > scaled_type;
>
>
>
> typedef typename rep_type::value_type value_type;
>
>
>
> typedef typename rep_type::reference reference;
>
>
>
> typedef typename rep_type::const_reference const_reference;
>
>
>
> typedef typename rep_type::pointer pointer;
>
>
>
> typedef typename rep_type::size_type size_type;
>
>
>
> typedef typename rep_type::difference_type difference_type;
>
>
>
>
> typedef dense_iterator<typename rep_type::iterator> iterator;
>
>
>
> typedef dense_iterator<typename rep_type::const_iterator> const_iterator;
>
>
>
>
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
>
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
>
>
> typedef linalg_vec<RepType, RepPtr, NN> Vec;
>
> typedef size_type Vec_size_type;
> typedef difference_type Vec_difference_type;
> typedef iterator Vec_iterator;
> typedef const_iterator Vec_const_iterator;
>
> class IndexArray {
> public:
>
> typedef Vec_size_type size_type;
> typedef Vec_difference_type difference_type;
> typedef Vec_size_type value_type;
>
> class iterator {
> public:
> typedef size_type value_type;
> typedef size_type reference;
> typedef size_type* pointer;
> typedef Vec_difference_type difference_type;
> typedef typename std::iterator_traits<Vec_iterator>::iterator_category iterator_category;
> iterator(Vec_iterator iter, Vec_iterator e) : i(iter), end(e) {
> while (*i == self::Vec_value_type(0)) ++i;
> }
> reference operator*() const { return i.index(); }
> iterator& operator++() {
> ++i; while (*i == self::Vec_value_type(0) && i != end) ++i;
> return *this; }
> iterator operator++(int) { iterator t = *this; ++(*this); return t; }
> iterator& operator--() {
> --i; while (*i == self::Vec_value_type(0) && i != end) --i;
> return *this; }
> iterator operator--(int) { iterator t = *this; --(*this); return t; }
> difference_type operator-(const iterator& x) const { return i - x.i; }
> bool operator==(const iterator& x) const { return i == x.i; }
> bool operator!=(const iterator& x) const { return i != x.i; }
> bool operator<(const iterator& x) const { return i < x.i; }
> Vec_iterator i;
> Vec_iterator end;
> };
> class const_iterator {
> public:
> typedef size_type value_type;
> typedef size_type reference;
> typedef size_type* pointer;
> typedef Vec_difference_type difference_type;
> typedef typename std::iterator_traits<Vec_iterator>::iterator_category iterator_category;
> const_iterator(Vec_const_iterator iter, Vec_const_iterator e)
> : i(iter), end(e) {
> while (*i == self::Vec_value_type(0) && i != end) ++i;
> }
> reference operator*() const { return i.index(); }
> const_iterator& operator++() {
> ++i; while (*i == self::Vec_value_type(0) && i != end) ++i;
> return *this; }
> const_iterator operator++(int) {
> const_iterator t = *this; ++(*this); return t; }
> const_iterator& operator--() {
> --i; while (*i == self::Vec_value_type(0)) --i;
> return *this; }
> const_iterator operator--(int) {
> const_iterator t = *this; --(*this); return t; }
> difference_type operator-(const const_iterator& x) const {
> return i - x.i; }
> bool operator==(const const_iterator& x) const { return i == x.i; }
> bool operator!=(const const_iterator& x) const { return i != x.i; }
> bool operator<(const const_iterator& x) const { return i < x.i; }
> Vec_const_iterator i;
> Vec_const_iterator end;
> };
>
> inline IndexArray(const Vec& v) : vec((Vec*)&v) { }
> inline iterator begin() { return iterator(vec->begin(), vec->end()); }
> inline iterator end() { return iterator(vec->end(), vec->end()); }
> inline const_iterator begin() const{
> return const_iterator(((const Vec*)vec)->begin(),
> ((const Vec*)vec)->end());
> }
> inline const_iterator end() const {
> return const_iterator(((const Vec*)vec)->end(),
> ((const Vec*)vec)->end()); }
>
> size_type size() const {
> size_type s = 0;
> Vec_const_iterator i;
> for (i = ((const Vec*)vec)->begin(); i != ((const Vec*)vec)->end(); ++i)
> if (*i != self::Vec_value_type(0)) ++s;
> return s;
> }
>
> Vec* vec;
> };
>
>
>
> typedef IndexArray IndexArrayRef;
>
>
>
> typedef light1D<value_type> subrange_type;
>
> typedef std::pair<size_type, size_type> range;
>
>
>
>
>
> inline linalg_vec() : rep(0) { }
>
>
> inline linalg_vec(rep_ptr x, size_type start_index)
> : rep(x), first(start_index) { }
>
>
>
> inline linalg_vec(const self& x) : rep(x.rep), first(x.first) { }
>
>
>
> inline ~linalg_vec() { }
>
>
>
> inline self& operator=(const self& x) {
> rep = x.rep;
> first = x.first;
> return *this;
> }
>
>
>
>
>
>
>
> inline iterator begin() { return iterator(rep->begin(), 0, first); }
>
>
> inline iterator end() { return iterator(rep->begin(), rep->size(), first); }
>
>
> inline const_iterator begin() const { return const_iterator(rep->begin(),
> 0, first); }
>
>
> inline const_iterator end() const{ return const_iterator(rep->begin(),
> rep->size(), first); }
>
>
> inline reverse_iterator rbegin() { return reverse_iterator(end()); }
>
>
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
>
> inline const_reverse_iterator rbegin() const {
> return reverse_iterator(end()); }
>
>
> inline const_reverse_iterator rend() const{
> return reverse_iterator(begin()); }
>
>
>
>
>
>
> inline reference operator[](size_type i) {
> ;
> return (*rep)[i - first];
> }
>
> inline subrange_type operator()(range r) {
> return subrange_type(data() + r.first, r.second - r.first);
> }
> inline subrange_type operator()(size_type s, size_type f)
> 
> {
> return subrange_type(data() + s, f - s);
> }
>
>
>
> inline const_reference operator[](size_type i) const {
> ;
> return (*rep)[i - first];
> }
>
>
>
>
>
>
> inline size_type size() const { return rep->size(); }
>
> inline size_type nnz() const { return rep->size(); }
>
> inline void resize(size_type n) { rep->resize(n); }
>
> inline void resize(size_type n, const value_type& x) { rep->resize(n, x); }
>
> size_type capacity() const { return rep->capacity(); }
>
>
> void reserve(size_type n) { rep->reserve(n); }
>
>
> inline const value_type* data() const { return &(*rep)[0]; }
>
>
> inline value_type* data() { return &(*rep)[0]; }
>
>
>
> inline iterator
> insert (iterator position, const value_type& x = value_type()) {
> return iterator(rep->insert(position.base(), x), position.index()+1);
>
> }
>
> inline IndexArrayRef nz_struct() const { return IndexArrayRef(*this); }
>
> inline self& adjust_index(size_type i) {
> first += i;
> return *this;
> }
>
>protected:
>
> rep_ptr rep;
> size_type first;
>};
># 363 "/usr/local/include/mtl/linalg_vec.h" 3
>template <class T, int NN = 0, class SizeType=unsigned int>
>class external_vec {
> typedef external_vec self;
>public:
> enum { N = NN };
>
> typedef external_vec<int> IndexArray;
>
>
>
>
> typedef dense_tag sparsity;
>
> typedef scaled1D< self > scaled_type;
>
> typedef SizeType size_type;
> typedef int difference_type;
>
>
> typedef T value_type;
>
> typedef T& reference;
>
> typedef T* pointer;
>
> typedef const T& const_reference;
>
> typedef const T* const_pointer;
># 409 "/usr/local/include/mtl/linalg_vec.h" 3
> typedef dense_iterator<T*,0,size_type> iterator;
> typedef dense_iterator<const T*,0,size_type> const_iterator;
>
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
>
> typedef self IndexArrayRef;
>
>
>
> typedef self subrange_type;
>
> typedef std::pair<size_type, size_type> range;
>
>
> typedef oned_tag dimension;
>
>
>
>
> inline external_vec() : rep(0), size_(0), first(0) { }
>
>
> inline external_vec(T* data)
> : rep(data), size_(N), first(0) { }
>
>
> inline external_vec(T* data, size_type n, size_type start = 0)
> : rep(data), size_(n), first(start) { }
>
>
> inline external_vec(const self& x)
> : rep(x.rep), size_(x.size_), first(x.first) { }
>
>
> inline self& operator=(const self& x) {
> rep = x.rep; size_ = x.size_; first = x.first; return *this;
> }
>
>
> inline ~external_vec() { }
># 463 "/usr/local/include/mtl/linalg_vec.h" 3
> inline iterator begin() { return iterator(rep, 0, first); }
>
>
> inline iterator end() { return iterator(rep, size(), first); }
>
>
> inline const_iterator begin() const {
> return const_iterator(rep, 0, first);
> }
>
>
> inline const_iterator end() const{
> return const_iterator(rep, size(), first);
> }
>
>
> inline reverse_iterator rbegin() {
>
> return reverse_iterator(end());
> }
>
>
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
>
> inline const_reverse_iterator rend() const{
> return const_reverse_iterator(begin());
> }
>
>
>
>
>
> inline reference operator[](size_type i) { return rep[i - first]; }
>
>
> inline const_reference operator[](size_type i) const { return rep[i - first]; }
>
>
> inline subrange_type operator()(size_type s, size_type f) const {
> return subrange_type(rep + s - first, f - s, 0);
> }
>
> inline subrange_type operator()(range r) {
> return subrange_type(data() + r.first, r.second - r.first, 0);
> }
>
>
>
>
> inline size_type size() const { return N ? N : size_; }
>
>
>
> inline size_type nnz() const { return size(); }
># 532 "/usr/local/include/mtl/linalg_vec.h" 3
> inline void resize(size_type n) { size_ = n; }
> inline void clear() { size_ = 0; }
>
>
>
> inline value_type* data() const { return rep; }
>
> inline self& adjust_index(size_type i) {
> first += i;
> return *this;
> }
>
>
>
>
> void push_back(const T& x) {
> rep[size_] = x;
> ++size_;
> }
>
>protected:
> T* rep;
> size_type size_;
> size_type first;
>};
>
>
>
>
>
>template <int N>
>struct __make_external {
> template <class T>
> inline external_vec<T,N> operator()(T* x) {
> return external_vec<T,N>(x);
> }
>};
>
>
>
>
>
>template <class Container>
>inline linalg_vec<Container>
>vec(const Container& x)
>{
> return linalg_vec<Container>(x);
>}
>
>}
># 28 "/usr/local/include/mtl/matrix_implementation.h" 2 3
># 1 "/usr/local/include/mtl/banded_indexer.h" 1 3
>
>
>
># 1 "/usr/local/include/mtl/orien.h" 1 3
>
>
>
>namespace mtl {
>
>struct row_orien;
>struct column_orien;
>struct row_major;
>struct column_major;
>
>
>
>
>struct row_orien {
> template <int MM, int NN> struct dims { enum { M = MM, N = NN }; };
> typedef row_tag orientation;
> typedef row_major constructor_tag;
> typedef column_orien transpose_type;
> template <class Dim>
> static typename Dim::size_type row(Dim d) { return d.first(); }
> template <class Dim>
> static typename Dim::size_type column(Dim d){ return d.second();}
> template <class Dim>
> static Dim map(Dim d) { return d; }
>};
>
>
>
>
>struct column_orien {
> template <int MM, int NN> struct dims { enum { M = NN, N = MM }; };
> typedef column_tag orientation;
> typedef row_orien transpose_type;
> typedef column_major constructor_tag;
> template <class Dim>
> static typename Dim::size_type row(Dim d) { return d.second(); }
> template <class Dim>
> static typename Dim::size_type column(Dim d){ return d.first(); }
>
>
>
>
>
>
> template <class Dim>
> static Dim map(Dim d) { return Dim(d.second(), d.first()); }
>
>};
>
>}
># 5 "/usr/local/include/mtl/banded_indexer.h" 2 3
>
>
>namespace mtl {
>
>
>template <class size_type, class Orien>
>class banded_indexer {
>public:
>
> enum { M = 0, N = 0 } ;
>
> typedef dimension<size_type> dim_type;
> typedef dimension<int> band_type;
>
> dim_type dim;
> band_type bandwidth;
>
> typedef typename Orien::orientation orientation;
> typedef banded_tag shape;
> typedef banded_indexer<size_type,
> typename Orien::transpose_type> transpose_type;
> typedef banded_indexer<size_type,
> typename Orien::transpose_type> strided_type;
>
> typedef Orien orienter;
>
> class OneDIndexer {
> public:
> inline OneDIndexer() { }
> inline OneDIndexer(size_type majornum, size_type s)
> : major_num(majornum), start(s) { }
> inline OneDIndexer(const OneDIndexer& x)
> : major_num(x.major_num), start(x.start) { }
>
> template <class OneDIterator> inline
> size_type row(OneDIterator i) const { return Orien::row(coords(i)); }
>
> template <class OneDIterator> inline
> size_type column(OneDIterator i) const { return Orien::column(coords(i)); }
>
> template <class OneDIterator> inline
> size_type minor(OneDIterator i) const { return coords(i).second(); }
>
> template <class OneDIterator> inline
> OneDIterator begin(OneDIterator i) const { return i; }
>
> inline size_type at(size_type i) const { return i - start; }
> protected:
> template <class OneDIterator> inline
> dim_type coords(OneDIterator i) const {
> return dim_type(major_num, i.index() + start);
> }
> size_type major_num;
> size_type start;
> };
> inline banded_indexer() { }
> inline banded_indexer(dim_type d, band_type band)
> : dim(d), bandwidth(band) { }
> inline banded_indexer(const banded_indexer& x)
> : dim(x.dim), bandwidth(x.bandwidth) { }
> inline banded_indexer(const strided_type& x, strideable)
> : dim(x.dim.transpose()), bandwidth(x.bandwidth) { }
> inline banded_indexer(const transpose_type& x, not_strideable)
> : dim(x.dim), bandwidth(x.bandwidth) { }
>
> template <class TwoDIterator> inline
> OneDIndexer deref(TwoDIterator iter) const {
> int i = iter.index();
> size_type start = std::max(i - int(bandwidth.first()),0);
> return OneDIndexer(i, start);
> }
> inline OneDIndexer deref(size_type i) const {
> size_type start = std::max(int(i) - int(bandwidth.first()),0);
> return OneDIndexer(i, start);
> }
> inline dim_type at(dim_type p) const {
> dim_type m = Orien::map(p);
> return dim_type(m.first(), m.second()
> - std::max(int(m.first()) - int(bandwidth.first()),0));
> }
>
> inline static dim_type twod_dim(dim_type d, band_type ) { return d; }
>
> inline static band_type twod_band(dim_type , band_type bw) { return bw; }
>
> inline size_type nrows() const { return Orien::row(dim); }
> inline size_type ncols() const { return Orien::column(dim); }
>
> inline int sub() const { return Orien::row(bandwidth); }
> inline int super() const { return Orien::column(bandwidth); }
>
>};
>
>
>
>template <class Orien, int MM, int NN, class size_type>
>struct gen_banded_indexer {
> typedef dimension<char,0,0> twod_dim_type;
> typedef gen_banded_indexer< typename Orien::transpose_type, MM, NN, size_type>
> transpose_type;
> typedef gen_banded_indexer< Orien, NN, MM, size_type> strided_type;
>
> typedef banded_indexer<size_type, Orien> type;
> template <class ST>
> struct bind {
> typedef gen_banded_indexer<Orien, MM, NN, ST> other;
> };
> typedef Orien orienter;
>};
>
>
>}
># 29 "/usr/local/include/mtl/matrix_implementation.h" 2 3
># 1 "/usr/local/include/mtl/partition.h" 1 3
>
>
>
>namespace mtl {
># 18 "/usr/local/include/mtl/partition.h" 3
> template <class Sequence1, class Sequence2, class Matrix, class MatrixP>
> inline void
> partition(const Sequence1& prows,
> const Sequence2& pcols,
> const Matrix& A, MatrixP& P)
> {
> typedef typename Matrix::size_type size_type;
> typedef typename Matrix::dim_type dim_type;
>
> ;
> ;
>
> typename Sequence1::const_iterator mi;
> typename Sequence2::const_iterator ni;
> size_type i, j, mprev, nprev;
>
> i = 0;
> mi = prows.begin();
> mprev = 0;
>
> j = 0;
> ni = pcols.begin();
> nprev = 0;
> P(i,j) = A.sub_matrix(mprev, *mi, nprev, *ni);
> nprev = *ni;
> for (++ni, ++j; ni != pcols.end(); ++ni, ++j) {
> P(i,j) = A.sub_matrix(mprev, *mi, nprev, *ni);
> nprev = *ni;
> }
> P(i,j) = A.sub_matrix(mprev, *mi, nprev, A.ncols());
>
> mprev = *mi;
>
> for (++mi, ++i; mi != prows.end(); ++mi, ++i) {
> j = 0;
> ni = pcols.begin();
> nprev = 0;
> P(i,j) = A.sub_matrix(mprev, *mi, nprev, *ni);
> nprev = *ni;
> for (++ni, ++j; ni != pcols.end(); ++ni, ++j) {
> P(i,j) = A.sub_matrix(mprev, *mi, nprev, *ni);
> nprev = *ni;
> }
> P(i,j) = A.sub_matrix(mprev, *mi, nprev, A.ncols());
>
> mprev = *mi;
> }
>
> j = 0;
> ni = pcols.begin();
> nprev = 0;
> P(i,j) = A.sub_matrix(mprev, A.nrows(), nprev, *ni);
> nprev = *ni;
> for (++ni, ++j; ni != pcols.end(); ++ni, ++j) {
> P(i,j) = A.sub_matrix(mprev, A.nrows(), nprev, *ni);
> nprev = *ni;
> }
> P(i,j) = A.sub_matrix(mprev, A.nrows(), nprev, A.ncols());
> }
>
>
>
> template <class Matrix, class MatrixP>
> inline void
> subdivide(typename Matrix::size_type split_row,
> typename Matrix::size_type split_col,
> const Matrix& A, MatrixP& P)
> {
> typedef typename Matrix::size_type size_type;
> size_type rsplits[1];
> size_type csplits[1];
>
> rsplits[0] = split_row;
> csplits[0] = split_col;
>
> partition(mtl::__make_external<sizeof(rsplits)/sizeof(*rsplits)>()(rsplits),
> mtl::__make_external<sizeof(csplits)/sizeof(*csplits)>()(csplits),
> A, P);
> }
>
>
>
>
>
> template <class Splits, class Vec, class VecP>
> inline void
> partition(const Splits& s, const Vec& x, VecP& p)
> {
> typedef typename Vec::size_type size_type;
> typedef typename Vec::value_type T;
> typename Splits::const_iterator si;
> si = s.begin();
> size_type i = 0;
> size_type prev = *si;
> p[i] = external_vec<T>(x.data(), *si);
> for (++si, ++i; si != s.end(); ++si, ++i) {
> p[i] = external_vec<T>(x.data() + prev, *si - prev);
> prev = *si;
> }
> p[i] = external_vec<T>(x.data() + prev, x.size() - prev);
> }
>
>
> template <class Vec, class VecP>
> inline void
> subdivide(typename Vec::size_type s, const Vec& x, VecP& p)
> {
> typedef typename Vec::value_type T;
> p[0] = external_vec<T>(x.data(), s);
> p[1] = external_vec<T>(x.data() + s, x.size() - s);
> }
>
>
>
>}
># 30 "/usr/local/include/mtl/matrix_implementation.h" 2 3
># 1 "/usr/local/include/mtl/light_matrix.h" 1 3
># 9 "/usr/local/include/mtl/light_matrix.h" 3
>namespace mtl {
>
>
>template <int Orien>
>struct TRANS {
> enum { RET = 0 };
>};
>
>template<>
>struct TRANS<ROW_MAJOR> {
> enum { RET = COL_MAJOR };
>};
>
>template<>
>struct TRANS<COL_MAJOR> {
> enum { RET = ROW_MAJOR };
>};
>
>
>template <class T, class SizeType, int Orien, int Strided>
>class light_matrix {
>public:
> typedef light_matrix self;
> typedef light_matrix light_matrix_t;
> typedef T* DataPtr;
>
> typedef rectangle_tag shape;
> typedef typename IF< EQUAL<Orien,ROW_MAJOR>::RET,
> row_tag, column_tag>::RET orientation;
>
> typedef typename IF< EQUAL<Orien,ROW_MAJOR>::RET,
> row_orien, column_orien>::RET orien;
>
> typedef light_matrix<T, SizeType, TRANS<Orien>::RET, Strided> transpose_type;
> typedef light_matrix<T, SizeType, Orien, !Strided> strided_type;
> typedef light_matrix<T, SizeType, Orien, Strided> scaled_type;
>
> typedef light_matrix<T, SizeType, Orien, Strided> submatrix_type;
>
> typedef int DiffType;
>
>
> typedef SizeType size_type;
>
> typedef DiffType difference_type;
>
> typedef T value_type;
> typedef value_type& reference;
> typedef const value_type& const_reference;
> typedef value_type* pointer;
>
> enum { M = 0, N = 0 };
>
>protected:
>
> static inline size_type& twod_pos(size_type& i, size_type& j) {
> if (Orien == ROW_MAJOR)
> return i;
> else
> return j;
> }
>
> static inline const size_type& twod_pos(const size_type& i,
> const size_type& j) {
> if (Orien == ROW_MAJOR)
> return i;
> else
> return j;
> }
>
> static inline size_type& oned_pos(size_type& i, size_type& j) {
> if (Orien == ROW_MAJOR)
> return j;
> else
> return i;
> }
>
> static inline const size_type& oned_pos(const size_type& i,
> const size_type& j) {
> if (Orien == ROW_MAJOR)
> return j;
> else
> return i;
> }
>
>
>
>
>public:
>
>
> typedef dense_tag sparsity;
>
> typedef external_tag storage_loc;
>
> typedef strideable strideability;
>
> class oned {
> public:
> typedef T& reference;
> typedef const T& const_reference;
> typedef T value_type;
> typedef T* pointer;
> typedef SizeType size_type;
> typedef int difference_type;
>
> enum { M = 0, N = 0 };
>
> typedef oned subrange_type;
> typedef dense_tag sparsity;
> typedef oned IndexArray;
> typedef oned IndexArrayRef;
>
> typedef oned_tag dimension;
>
> template <int isConst>
> class __iterator {
> typedef __iterator self;
> public:
> typedef typename oned::value_type value_type;
> typedef typename oned::pointer pointer;
> typedef typename oned::size_type size_type;
> typedef typename oned::difference_type difference_type;
>
> typedef typename IF<isConst, typename oned::const_reference,
> typename oned::reference>::RET reference;
>
> typedef std::random_access_iterator_tag iterator_category;
>
> inline __iterator(DataPtr d,
> size_type ii, size_type jj,
> size_type os, size_type s)
> : data(d), i(ii), j(jj), offset(os), stride(s) { }
>
> inline __iterator(const self& x)
> : data(x.data), i(x.i), j(x.j), offset(x.offset), stride(x.stride) { }
>
> inline self& operator=(const self& x) {
> data = x.data; i = x.i; j = x.j; offset = x.offset; stride = x.stride;
> return *this;
> }
>
> inline __iterator() : data(0), i(0), j(0), offset(0), stride(0) { }
>
> inline reference operator*() const { return data[offset]; }
> inline self& operator++() { ++pos(); offset += stride; return *this; }
> inline self& operator+=(size_type n) {
> pos() += n; offset += stride*n; return *this;
> }
> inline self operator++(int) { self t = *this; ++(*this); return t; }
> inline self& operator--() { --pos(); offset -= stride; return *this; }
> inline self& operator-=(size_type n) {
> pos() -= n; offset -= stride*n; return *this; }
> inline self operator--(int) { self t = *this; --(*this); return t; }
> inline bool operator!=(const self& x) const { return pos() != x.pos(); }
> inline bool operator==(const self& x) const { return pos() == x.pos(); }
> inline bool operator<(const self& x) const { return pos() < x.pos(); }
> inline size_type index() const { return pos(); }
>
> inline size_type& pos() { return oned_pos(i,j); }
> inline const size_type& pos() const { return oned_pos(i,j); }
>
> inline size_type row() const { return i; }
> inline size_type column() const { return j; }
> protected:
> DataPtr data;
> size_type i, j;
> size_type offset;
> size_type stride;
> };
>
> typedef __iterator<0> iterator;
> typedef __iterator<1> const_iterator;
>
> inline oned(DataPtr d, size_type ii, size_type jj,
> size_type ie, size_type je,
> size_type os, size_type ld)
> : data(d), i(ii), j(jj), iend(ie), jend(je),
> offset(os), ldim(ld) { }
>
> inline oned(const oned& x)
> : data(x.data), i(x.i), j(x.j),
> iend(x.iend), jend(x.jend),
> offset(x.offset), ldim(x.ldim) { }
>
> inline oned& operator=(const oned& x) {
> data = x.data; i = x.i; j = x.j;
> iend = x.iend; jend = x.jend;
> offset = x.offset; ldim = x.ldim;
> return *this;
> }
> inline oned()
> : data(0), i(0), j(0), iend(0), jend(0), offset(0), ldim(0) { }
>
> inline ~oned() { }
>
> inline reference operator[](size_type n) {
> return data[ Strided ? offset + n * ldim : offset + n];
> }
>
> inline const_reference operator[](size_type n) const {
> return data[ Strided ? offset + n * ldim : offset + n];
> }
>
> inline iterator begin() {
> return iterator(data, i, j, offset, Strided ? ldim : 1);
> }
> inline iterator end() {
> size_type iiend, jjend;
> if (Orien == ROW_MAJOR) { iiend = i; jjend = jend; }
> else { iiend = iend; jjend = j; }
>
> return iterator(data, iiend, jjend, offset, Strided ? ldim: 1);
> }
>
> inline const_iterator begin() const {
> return const_iterator(data, i, j, offset, Strided ? ldim : 1);
> }
> inline const_iterator end() const {
> size_type iiend, jjend;
> if (Orien == ROW_MAJOR) { iiend = i; jjend = jend; }
> else { iiend = iend; jjend = j; }
>
> return const_iterator(data, iiend, jjend, offset, Strided ? ldim : 1);
> }
>
> protected:
> DataPtr data;
> size_type i, j;
> size_type iend, jend;
> size_type offset;
> size_type ldim;
> };
>
> typedef oned OneD;
> typedef OneD OneDRef;
> typedef OneD Row;
> typedef OneD RowRef;
> typedef OneD Column;
> typedef OneD ColumnRef;
>
>
> template <int Const>
> class __iterator {
> typedef __iterator self;
> public:
> typedef std::random_access_iterator_tag iterator_category;
> typedef oned value_type;
> typedef value_type* pointer;
>
>
>
>
>
> typedef SizeType size_type;
> typedef DiffType difference_type;
>
>
> typedef typename IF<Const, const oned, oned>::RET reference;
>
> inline __iterator(DataPtr d, size_type ii, size_type jj,
> size_type ie, size_type je, size_type ld)
> : data(d), i(ii), j(jj), iend(ie), jend(je), offset(0), ldim(ld) {
> if (Strided) stride = 1; else stride = ldim;
> }
>
> inline __iterator() : data(0), i(0), j(0), iend(0), jend(0),
> offset(0), stride(0), ldim(0) { }
>
> inline __iterator(const self& x)
> : data(x.data), i(x.i), j(x.j),
> iend(x.iend), jend(x.jend), offset(x.offset),
> stride(x.stride), ldim(x.ldim) { }
>
> inline self& operator=(const self& x) {
> data = x.data; i = x.i; j = x.j;
> iend = x.iend; jend = x.jend;
> offset = x.offset; stride = x.stride; ldim = x.ldim;
> return *this;
> }
> inline reference operator*() const {
> return oned(data, i, j, iend, jend, offset, ldim);
> }
>
> inline self& operator++() { ++pos(); offset += stride; return *this; }
> inline self& operator+=(size_type n) {
> pos() += n; offset += stride*n; return *this; }
> inline self operator++(int) { self t = *this; ++(*this); return t; }
> inline self& operator--() { --pos(); offset -= stride; return *this; }
> inline self& operator-=(size_type n) {
> pos() -= n; offset -= stride*n; return *this; }
> inline self operator--(int) { self t = *this; --(*this); return t; }
> inline bool operator!=(const self& x) const { return pos() != x.pos(); }
> inline bool operator==(const self& x) const { return pos() == x.pos(); }
> inline bool operator<(const self& x) const { return pos() < x.pos(); }
> inline size_type index() const { return pos(); }
>
> inline size_type& pos() { return twod_pos(i,j); }
> inline const size_type& pos() const { return twod_pos(i,j); }
>
> inline size_type row() const { return i; }
> inline size_type column() const { return j; }
>
> protected:
> DataPtr data;
> size_type i, j;
> size_type iend, jend;
> size_type offset;
> size_type stride;
> size_type ldim;
> };
>
> typedef __iterator<0> iterator;
> typedef __iterator<1> const_iterator;
>
>
> inline light_matrix(DataPtr d, size_type m, size_type n, size_type ld)
> : data_(d), nrows_(m), ncols_(n), ldim(ld) { }
>
> inline light_matrix(DataPtr d, size_type m, size_type n)
> : data_(d), nrows_(m), ncols_(n), ldim(Orien == ROW_MAJOR ? n : m) { }
>
>
> inline light_matrix(const light_matrix& x)
> : data_(x.data_), nrows_(x.nrows_), ncols_(x.ncols_), ldim(x.ldim) { }
>
>
> inline const light_matrix& operator=(const light_matrix& x) {
> data_ = x.data_; nrows_ = x.nrows_; ncols_ = x.ncols_; ldim = x.ldim;
> return *this;
> }
>
> inline light_matrix() : data_(0), nrows_(0), ncols_(0), ldim(0) { }
>
> inline light_matrix(const strided_type& x, do_strided s)
> : data_(x.data_), nrows_(x.nrows_), ncols_(x.ncols_), ldim(x.ldim) { }
>
> template <class StridedType>
> inline light_matrix(const StridedType& x, do_strided s)
> : data_(x.data_), nrows_(x.nrows_), ncols_(x.ncols_), ldim(x.ldim) { }
>
>
> inline ~light_matrix() { }
>
>
> inline iterator begin() {
> return iterator(data_, 0, 0, nrows_, ncols_, ldim);
> }
>
> inline iterator end() {
> return iterator(data_, nrows_, ncols_, nrows_, ncols_, ldim);
> }
>
>
> inline const_iterator begin() const {
> return const_iterator(data_, 0, 0, nrows_, ncols_, ldim);
> }
>
> inline const_iterator end() const {
> return const_iterator(data_, nrows_, ncols_, nrows_, ncols_, ldim);
> }
>
>
> inline oned operator[](size_type n) {
> if (Orien == ROW_MAJOR)
> return oned(data_, n, 0, nrows_, ncols_, Strided ? n : ldim * n, ldim);
> else
> return oned(data_, 0, n, nrows_, ncols_, Strided ? n : ldim * n, ldim);
> }
>
> inline const oned operator[](size_type n) const {
> if (Orien == ROW_MAJOR)
> return oned(data_, n, 0, nrows_, ncols_, Strided ? n : ldim * n, ldim);
> else
> return oned(data_, 0, n, nrows_, ncols_, Strided ? n : ldim * n, ldim);
> }
>
>
> inline reference operator()(size_type i, size_type j) {
> return Orien == ROW_MAJOR ? operator[](i)[j] : operator[](j)[i];
> }
>
>
> inline const_reference operator()(size_type i, size_type j) const {
> return Orien == ROW_MAJOR ? operator[](i)[j] : operator[](j)[i];
> }
>
> inline size_type nrows() const { return nrows_; }
> inline size_type ncols() const { return ncols_; }
>
>
> inline submatrix_type sub_matrix(size_type i, size_type iend,
> size_type j, size_type jend) const
> {
> if (Strided)
> return submatrix_type(data_ + oned_pos(i,j) * ldim + twod_pos(iend,jend),
> iend - i, jend - j, ldim);
> else
> return submatrix_type(data_ + twod_pos(i,j) * ldim + oned_pos(iend,jend),
> iend - i, jend - j, ldim);
> }
>
>
> DataPtr data_;
> size_type nrows_, ncols_;
> size_type ldim;
>};
>
>
>}
># 31 "/usr/local/include/mtl/matrix_implementation.h" 2 3
>
># 1 "/usr/local/include/mtl/initialize.h" 1 3
># 20 "/usr/local/include/mtl/initialize.h" 3
># 1 "/usr/local/include/mtl/mtl_complex.h" 1 3
># 21 "/usr/local/include/mtl/initialize.h" 2 3
># 1 "/usr/local/include/mtl/conj.h" 1 3
># 17 "/usr/local/include/mtl/conj.h" 3
>namespace std {
>
>
>inline double conj(double a) {
> return a;
>}
>inline float conj(float a) {
> return a;
>}
>inline int conj(int a) {
> return a;
>}
>inline bool conj(bool a) {
> return a;
>}
>
>
>inline double real(double a) {
> return a;
>}
>inline double imag(double) {
> return 0.0;
>}
>
>inline float real(float a) {
> return a;
>}
>inline float imag(float) {
> return 0.0;
>}
>
>
>
>
>}
># 22 "/usr/local/include/mtl/initialize.h" 2 3
># 1 "/usr/local/include/mtl/mtl_set.h" 1 3
>
>
>
># 1 "/usr/local/include/mtl/dim_calc.h" 1 3
>
>
>
>
>
>namespace mtl {
>
>
>
>template <class Vector>
>class dim_n {
>public:
>
>
>
>
> typedef fast::count<0> RET;
>
>};
>
>
>
>template <class Matrix>
>class dim_m {
>public:
>
>
>
>
> typedef fast::count<0> RET;
>
>};
>
>}
># 5 "/usr/local/include/mtl/mtl_set.h" 2 3
>
>
>
>
>
>
>namespace mtl {
>
>template <class Vector, class T> inline
>void
>oned_set(Vector x, const T& alpha, fast::count<0>)
>{
> mtl_algo::fill(x.begin(), x.end(), alpha);
>}
># 27 "/usr/local/include/mtl/mtl_set.h" 3
>template <class Vector, class T> inline
>void
>set__(Vector x, const T& alpha, oned_tag)
>{
> oned_set(x, alpha, typename dim_n<Vector>::RET());
>}
>
>
>template <class Matrix, class T> inline
>void
>set__(Matrix A, const T& alpha, fast::count<0>)
>{
> typename Matrix::iterator i;
> typename Matrix::OneD::iterator j, jend;
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> *j = alpha;
> }
>}
># 58 "/usr/local/include/mtl/mtl_set.h" 3
>template <class Matrix, class T> inline
>void
>set__(Matrix A, const T& alpha, twod_tag)
>{
> set__(A, alpha, typename dim_m<Matrix>::RET());
>}
># 88 "/usr/local/include/mtl/mtl_set.h" 3
>template <class LinalgObj, class T>
>inline void
>set(LinalgObj A, const T& alpha)
>{
> typedef typename linalg_traits<LinalgObj>::dimension Dim;
> set__(A, alpha, Dim());
>}
>
>
>
>template <class LinalgObj, class T>
>inline void
>set_value(LinalgObj A, const T& alpha)
>{
> typedef typename linalg_traits<LinalgObj>::dimension Dim;
> set__(A, alpha, Dim());
>}
>
>}
># 23 "/usr/local/include/mtl/initialize.h" 2 3
>
>namespace mtl {
>
>using std::complex;
>using std::conj;
>
>class symmetric_tag;
>
>
>template <class Matrix, class T>
>void
>__initialize(Matrix& A, matrix_market_stream<T>& s,
> symmetric_tag)
>{
> typedef typename Matrix::value_type VT;
> entry2<VT> e;
>
> if ( s.is_symmetric() ) {
> while( ! s.eof() ) {
> s >> e;
> int row = e.row;
> int col = e.col;
> A(row, col) = e.value;
> }
> } else {
> std::cout << " matrix type is symmetric but the matrix in the file is not" << std::endl;
> ((0) ? static_cast<void> (0) : (__assert_fail ("0", "/usr/local/include/mtl/initialize.h", 49, __PRETTY_FUNCTION__), static_cast<void> (0)));
> }
>}
>
>template <class Matrix, class ANY_TAG, class T>
>void
>__initialize(Matrix& A, matrix_market_stream<T>& s,
> ANY_TAG)
>{
> typedef typename Matrix::value_type VT;
> entry2<VT> e;
>
> if ( s.is_symmetric() ) {
> while( ! s.eof() ) {
> s >> e;
> int row = e.row;
> int col = e.col;
> A(row, col) = e.value;
> if ( s.is_hermitian() )
> A(e.col, e.row) = std::conj(e.value);
> else
> A(e.col, e.row) = e.value;
> }
> } else {
> while( ! s.eof() ) {
> s >> e;
> int row = e.row;
> int col = e.col;
> A(row, col) = e.value;
> }
> }
>}
>
>template <class Matrix, class TT>
>void
>initialize(Matrix& A, matrix_market_stream<TT>& s)
>{
> typedef typename Matrix::value_type T;
> typedef typename Matrix::shape Shape;
> mtl::set_value(A, T(0));
> mtl::__initialize(A, s, Shape());
>}
>
>
>template <class Matrix, class TT>
>void
>initialize(Matrix& A, harwell_boeing_stream<TT>& s)
>{
> typedef typename Matrix::size_type Int;
> typedef typename Matrix::value_type T;
>
> mtl::set_value(A, T(0));
> entry2<T> e;
>
> while( ! s.eof() ) {
> s >> e;
> Int row = e.row;
> Int col = e.col;
> A(row, col) = e.value;
> }
>}
>
>}
># 33 "/usr/local/include/mtl/matrix_implementation.h" 2 3
>
>namespace mtl {
>
>template < class T, class Shape, class Storage, class Orientation>
>struct matrix;
>
>template <int MM, int NN>
>class rectangle;
>
>template <int External>
>struct dense;
># 55 "/usr/local/include/mtl/matrix_implementation.h" 3
>template <class TwoDGen, class IndexerGen>
>class matrix_implementation {
> typedef matrix_implementation<TwoDGen,IndexerGen> self;
>public:
> typedef typename IndexerGen::twod_dim_type twoddim;
>
> enum { M = twoddim::M, N = twoddim::N };
> typedef typename TwoDGen::type TwoD;
>
> typedef typename TwoD::size_type size_type;
> typedef mtl::dimension<size_type> dyn_dim;
>
> typedef twod_tag dimension;
>
> typedef typename IndexerGen::type Indexer;
>
> typedef typename TwoD::value_type OldOneD;
> typedef typename TwoD::reference OldOneDRef;
> typedef typename TwoD::iterator oned_iterator;
> typedef typename TwoD::const_iterator const_oned_iterator;
>
> typedef typename Indexer::dim_type dim_type;
> typedef typename Indexer::band_type band_type;
>
> typedef oned_part<OldOneD, OldOneD, typename Indexer::OneDIndexer> OneD;
> typedef oned_part<OldOneD, OldOneDRef, typename Indexer::OneDIndexer> OneDRef;
> typedef typename TwoD::value_type TwoD_value_type;
> typedef typename TwoD_value_type::value_type value_type;
> typedef typename TwoD_value_type::reference reference;
> typedef typename TwoD_value_type::const_reference const_reference;
> typedef typename TwoD_value_type::pointer pointer;
> typedef typename TwoD_value_type::difference_type difference_type;
>
> typedef typename Indexer::shape shape;
> typedef typename Indexer::orientation orientation;
> typedef typename TwoD::sparsity sparsity;
> typedef typename TwoD::storage_loc storage_loc;
>
> typedef matrix_implementation< TwoDGen,
> typename IndexerGen::transpose_type > transpose_type;
>
> typedef matrix_implementation< typename TwoDGen::transpose_type,
> typename IndexerGen::strided_type > strided_type;
>
> typedef matrix_implementation< typename TwoDGen::banded_view_type,
> typename IndexerGen::strided_type > banded_view_type;
>
> typedef typename TwoD::strideability strideability;
>
> typedef matrix_implementation< gen_scaled2D<TwoD, value_type>,
> IndexerGen > scaled_type;
>
> typedef OneD NewOneD;
>
> template <int isConst>
> class _iterator {
> typedef _iterator self;
> typedef typename IF<isConst, const_oned_iterator,oned_iterator>::RET Iterator;
> public:
>
> typedef typename std::iterator_traits<Iterator>::difference_type
> difference_type;
>
>
>
>
>
> typedef typename IF<isConst, const NewOneD, NewOneD>::RET value_type;
> typedef typename IF<isConst, const NewOneD, NewOneD>::RET reference;
> typedef typename IF<isConst, const NewOneD*, NewOneD*>::RET pointer;
>
> typedef typename std::iterator_traits<Iterator>::iterator_category
> iterator_category;
>
> typedef difference_type Distance;
> typedef Iterator iterator_type;
>
> inline difference_type index() const { return iter.index(); }
>
> inline _iterator() { }
>
> inline _iterator(Iterator x, Indexer ind)
> : iter(x), indexer(ind) { }
>
> inline _iterator(const self& x)
> : iter(x.iter), indexer(x.indexer) { }
>
> inline self& operator=(const self& x) {
> iter = x.iter; indexer = x.indexer; return *this;
> }
>
> inline operator Iterator() { return iter; }
>
> inline Iterator base() const { return iter; }
>
> inline reference operator*() const {
> typename Indexer::OneDIndexer oned_indexer = indexer.deref(iter);
>
>
>
> return reference(*iter, oned_indexer);
> }
>
> inline self& operator++() { ++iter; return *this; }
>
> inline self operator++(int) {
> self tmp = (*this);
> ++(*this);
> return tmp;
> }
>
> inline self& operator--() { --iter; return *this; }
>
> inline self operator--(int) {
> self tmp = (*this);
> --(*this);
> return tmp;
> }
>
> inline self operator+(Distance n) const {
> self tmp = (*this);
> tmp += n;
> return tmp;
> }
>
> inline self& operator+=(Distance n) {
> iter += n; return (*this);
> }
>
> inline self operator-(Distance n) const {
> self tmp = (*this);
> tmp -= n;
> return tmp;
> }
>
> inline self& operator-=(Distance n) {
> iter -= n; return (*this);
> }
>
> inline value_type operator[](Distance n) const {
> self tmp = (*this);
> return *(tmp += n);
> }
>
> inline Distance operator-(const self& y) {
> return iter - y.iter;
> }
>
> inline bool operator==(const self& y) const {
> return iter == y.iter;
> }
>
> inline bool operator!=(const self& y) const {
> return iter != y.iter;
> }
>
> inline bool operator<(const self& y) const {
> return iter < y.iter;
> }
>
> protected:
> Iterator iter;
> Indexer indexer;
> };
>
> typedef _iterator<0> iterator;
> typedef _iterator<1> const_iterator;
>
> typedef reverse_iter<iterator> reverse_iterator;
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
> typedef typename Indexer::orienter orien;
>
>
> inline matrix_implementation() { }
>
> inline matrix_implementation(dim_type dim, size_type nnz_max)
> : twod(Indexer::twod_dim(orien::map(dim)), nnz_max),
> indexer(orien::map(dim)) { }
>
> inline matrix_implementation(dim_type dim)
> : twod(Indexer::twod_dim(orien::map(dim))),
> indexer(orien::map(dim)) { }
>
> inline matrix_implementation(dim_type dim, band_type bw)
> : twod(Indexer::twod_dim(orien::map(dim), orien::map(bw)),
> Indexer::twod_band(orien::map(dim), orien::map(bw))),
> indexer(orien::map(dim), orien::map(bw)) { }
>
> inline matrix_implementation(const TwoD& x, Indexer ind)
> : twod(x), indexer(ind) { }
>
>
> inline matrix_implementation(const matrix_implementation& x)
> : twod(x.twod), indexer(x.indexer) { }
>
> inline matrix_implementation(const matrix_implementation& x,
> do_strided s)
> : twod(x.twod), indexer(x.indexer) { }
>
> inline self& operator=(const self& x) {
> twod = x.twod; indexer = x.indexer;
> return *this;
> }
>
>
>
>
> inline matrix_implementation(const transpose_type& x,
> do_transpose, do_transpose)
> : twod(x.get_twod()), indexer(x.get_indexer(), not_strideable()) { }
>
> inline matrix_implementation(const strided_type& x, do_strided, do_strided)
> : twod(x.get_twod(), do_transpose(), do_transpose()),
> indexer(x.get_indexer(), strideable()) { }
>
> template <class MatrixT, class ScalarT>
> inline matrix_implementation(const MatrixT& x, const ScalarT& y, do_scaled)
> : twod(x.get_twod(), y), indexer(x.get_indexer()) { }
>
>
>
>
>
> inline matrix_implementation(pointer data, dim_type dim, char)
> : twod(data, orien::map(dim)), indexer(orien::map(dim)) { }
>
> inline matrix_implementation(pointer data, dim_type dim, size_type ld)
> : twod(data, orien::map(dim), ld), indexer(orien::map(dim)) { }
>
>
> inline matrix_implementation(pointer data, dim_type dim, size_type ld,
> dyn_dim starts, char)
> : twod(data, orien::map(dim), ld, orien::map(starts), char()),
> indexer(orien::map(dim)) { }
>
> inline matrix_implementation(pointer data, dim_type dim,
> band_type bw)
> : twod(data, orien::map(dim), orien::map(bw)),
> indexer(orien::map(dim), orien::map(bw)) { }
>
> inline matrix_implementation(pointer data, dim_type dim, size_type ld,
> band_type bw)
> : twod(data, orien::map(dim), ld, orien::map(bw)),
> indexer(orien::map(dim)) { }
>
>
> inline matrix_implementation(dim_type dim, size_type nnz,
> pointer val, size_type* ptrs, size_type* inds)
> : twod(orien::map(dim), nnz, val, ptrs, inds),
> indexer(orien::map(dim)) { }
>
>
> template <class MatrixT>
> inline matrix_implementation(const MatrixT& x, band_type bw)
> : twod(x.twod, orien::map(bw), banded_tag()),
> indexer(orien::map(dim_type(x.nrows(), x.ncols())), orien::map(bw)) { }
>
>
> template <class Matrix, class ST, int BM, int BN>
> inline matrix_implementation(const Matrix& x,
> mtl::dimension<ST,BM,BN> bd, char)
> : twod(x.twod, orien::map(bd)),
> indexer(orien::map(dim_type(x.nrows()/bd.first(),
> x.ncols()/bd.second()))) { }
>
>
> inline matrix_implementation(pointer data)
> : twod(data, orien::map(dim_type(0, 0))),
> indexer(orien::map(dim_type(0, 0))) { }
>
> inline matrix_implementation(pointer data, size_type ld)
> : twod(data, orien::map(dim_type(0, 0)), ld),
> indexer(orien::map(dim_type(0, 0))) { }
>
>
> typedef matrix_market_stream<value_type> mmstream;
> typedef harwell_boeing_stream<value_type> hbstream;
>
> template <class Me>
> inline matrix_implementation(mmstream& m_in, Me& me)
> : twod(m_in, orien()), indexer(orien::map(dim_type(m_in.nrows(),
> m_in.ncols())))
> {
> mtl::initialize(me, m_in);
> }
> template <class Me>
> inline matrix_implementation(hbstream& m_in, Me& me)
> : twod(m_in, orien()), indexer(orien::map(dim_type(m_in.nrows(),
> m_in.ncols())))
> {
> mtl::initialize(me, m_in);
> }
> template <class Me>
> inline matrix_implementation(mmstream& m_in, band_type bw, Me& me)
> : twod(m_in, orien(),
> Indexer::twod_band(orien::map(dim_type(m_in.nrows(),
> m_in.ncols())),
> orien::map(bw))),
> indexer(orien::map(dim_type(m_in.nrows(), m_in.ncols())),
> orien::map(bw))
> {
> mtl::initialize(me, m_in);
> }
> template <class Me>
> inline matrix_implementation(hbstream& m_in, band_type bw, Me& me)
> : twod(m_in, orien(),
> Indexer::twod_band(orien::map(dim_type(m_in.nrows(),
> m_in.ncols())),
> orien::map(bw))),
> indexer(orien::map(dim_type(m_in.nrows(), m_in.ncols())),
> orien::map(bw))
> {
> mtl::initialize(me, m_in);
> }
>
> inline ~matrix_implementation() { }
>
>
> inline iterator begin() { return iterator(twod.begin(), indexer); }
> inline iterator end() { return iterator(twod.end(), indexer); }
>
> inline const_iterator begin() const {
> return const_iterator(twod.begin(),indexer);
> }
> inline const_iterator end() const {
> return const_iterator(twod.end(),indexer);
> }
>
> inline reverse_iterator rbegin() { return reverse_iterator(end()); }
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
> inline typename OneD::reference operator()(size_type i, size_type j) {
> dyn_dim p = indexer.at(dyn_dim(i, j));
> return twod(p.first(), p.second());
> }
> inline typename OneD::const_reference operator()(size_type i,
> size_type j) const {
> dyn_dim p = indexer.at(dyn_dim(i, j));
> return twod(p.first(), p.second());
> }
>
>
> inline OneDRef operator[](size_type n) {
> return OneDRef(twod[n], indexer.deref(n));
> }
> inline const OneDRef operator[](size_type n) const {
> return OneDRef((OldOneDRef)twod[n], indexer.deref(n));
> }
>
>
> inline size_type nrows() const { return indexer.nrows(); }
> inline size_type ncols() const { return indexer.ncols(); }
> inline size_type noneds() const { return twod.major(); }
> inline size_type major() const { return twod.major(); }
> inline size_type minor() const { return twod.minor(); }
> inline size_type nnz() const { return twod.nnz(); }
> inline size_type capacity() const { return twod.capacity(); }
>
>
> inline int sub() const { return indexer.sub(); }
> inline int super() const { return indexer.super(); }
>
>
> inline bool is_upper() const { return false; }
> inline bool is_lower() const { return false; }
> inline bool is_unit() const { return false; }
>
> inline const TwoD& get_twod() const { return twod; }
> inline const Indexer& get_indexer() const { return indexer; }
>
> inline void print() const { twod.print(); }
>
>
> inline value_type* data() { return twod.data(); }
> inline const value_type* data() const { return twod.data(); }
>
>
> inline value_type* get_val() { return twod.get_val(); }
> inline const value_type* get_val() const { return twod.get_val(); }
> inline size_type* get_ind() { return twod.get_ind(); }
> inline const size_type* get_ind() const { return twod.get_ind(); }
> inline size_type* get_ptr() { return twod.get_ptr(); }
> inline const size_type* get_ptr() const { return twod.get_ptr(); }
>
> template <class Matrix>
> inline void fast_copy(const Matrix& x) { twod.fast_copy(x); }
>
>
>
> TwoD twod;
> Indexer indexer;
>};
>
>
>template <class TwoDGen, class IndexerGen>
>class column_matrix;
># 468 "/usr/local/include/mtl/matrix_implementation.h" 3
>template <class TwoDGen, class IndexerGen>
>class row_matrix : public matrix_implementation<TwoDGen, IndexerGen> {
> typedef matrix_implementation<TwoDGen, IndexerGen> Base;
>public:
> typedef typename Base::value_type value_type;
> typedef typename Base::size_type size_type;
> typedef typename Base::pointer pointer;
> typedef typename Base::reference reference;
> typedef typename Base::const_reference const_reference;
> typedef typename Base::dim_type dim_type;
> typedef typename Base::dyn_dim dyn_dim;
> typedef typename Base::TwoD TwoD;
> typedef typename Base::OneD OneD;
> typedef typename Base::OneDRef OneDRef;
> typedef typename Base::Indexer Indexer;
> typedef OneD Row;
> typedef OneDRef RowRef;
> enum { M = Indexer::M, N = Indexer::N };
> typedef column_matrix<TwoDGen, typename IndexerGen::transpose_type>
> transpose_type;
> typedef column_matrix<typename TwoDGen::transpose_type,
> typename IndexerGen::strided_type> strided_type;
>
> typedef row_matrix<typename TwoDGen::banded_view_type,
> gen_banded_indexer<typename IndexerGen::orienter,M,N,size_type> > banded_view_type;
>
> typedef typename Indexer::band_type band_type;
># 516 "/usr/local/include/mtl/matrix_implementation.h" 3
> inline row_matrix() { }
>
> inline row_matrix& operator=(const row_matrix& x) {
> Base::operator=(x);
> return *this;
> }
>
> inline row_matrix(size_type m, size_type n)
> : Base(dim_type(m, n)) { }
> inline row_matrix(size_type m, size_type n, size_type nnz_max)
> : Base(dim_type(m, n), nnz_max) { }
> inline row_matrix(size_type m, size_type n, int sub, int super)
> : Base(dim_type(m, n), typename Indexer::band_type(sub, super)) { }
>
>
> inline row_matrix(pointer data, size_type m, size_type n)
> : Base(data, dim_type(m, n), char()) { }
> inline row_matrix(pointer data, size_type m, size_type n, size_type ld)
> : Base(data, dim_type(m, n), ld) { }
>
>
> inline row_matrix(pointer data, size_type m, size_type n,
> size_type ld, dyn_dim starts)
> : Base(data, dim_type(m, n), ld, starts, char()) { }
>
> inline row_matrix(pointer data, size_type m, size_type n,
> int sub, int super)
> : Base(data, dim_type(m, n),
> band_type(sub, super)) { }
> inline row_matrix(pointer data, size_type m, size_type n, size_type ld,
> int sub, int super)
> : Base(data, dim_type(m, n), ld,
> band_type(sub, super)) { }
>
> inline row_matrix(pointer data)
> : Base(data) { }
>
>
> inline row_matrix(size_type m, size_type n, size_type nnz,
> pointer val, size_type* ptrs, size_type* inds)
> : Base(dim_type(m, n), nnz, val, ptrs, inds) { }
>
>
> template <class Matrix>
> inline row_matrix(int sub, int super, const Matrix& x)
> : Base(x, band_type(sub, super)) { }
>
>
> template <class Matrix, class ST, int BM, int BN>
> inline row_matrix(const Matrix& x, mtl::dimension<ST,BM,BN> bdim)
> : Base(x, bdim, char()) { }
>
>
> typedef matrix_market_stream<value_type> mmstream;
> typedef harwell_boeing_stream<value_type> hbstream;
> inline row_matrix(mmstream & m_in) : Base(m_in, *this) { }
> inline row_matrix(hbstream & m_in) : Base(m_in, *this) { }
> inline row_matrix(mmstream& m_in, int sub, int super)
> : Base(m_in, band_type(sub, super), *this) { }
> inline row_matrix(hbstream& m_in, int sub, int super)
> : Base(m_in, band_type(sub, super), *this) { }
>
> template <class Subclass>
> inline row_matrix(mmstream & m_in, Subclass& s) : Base(m_in, s) { }
> template <class Subclass>
> inline row_matrix(hbstream & m_in, Subclass& s) : Base(m_in, s) { }
> template <class Subclass>
> inline row_matrix(mmstream& m_in, int sub, int super, Subclass& s)
> : Base(m_in, band_type(sub, super), s) { }
> template <class Subclass>
> inline row_matrix(hbstream& m_in, int sub, int super, Subclass& s)
> : Base(m_in, band_type(sub, super), s) { }
>
>
> inline row_matrix(const row_matrix& x)
> : Base(x) { }
>
>
> inline row_matrix(const row_matrix& x, do_strided)
> : Base(x) { }
>
>
> inline row_matrix(const transpose_type& x, do_transpose t)
> : Base(x, t, t) { }
>
>
> inline row_matrix(const strided_type& x, do_strided s)
> : Base(x, s, s) { }
>
>
> template <class MatrixT, class ScalarT>
> inline row_matrix(const MatrixT& x, const ScalarT& y, do_scaled s)
> : Base(x, y, s) { }
>
> inline row_matrix(const TwoD& x, Indexer ind)
> : Base(x, ind) { }
>
> inline ~row_matrix() { }
>
> inline void resize(size_type m, size_type n) {
> Base::twod.resize(m, n);
> Base::indexer.dim = dim_type(m, n);
> }
>
>
>
> typedef typename TwoDGen::submatrix_type SubTwoDGen;
> typedef typename SubTwoDGen::type::size_type new_sizeT;
>
>
>
> typedef typename IndexerGen:: template bind<new_sizeT>::other SubMatIndexerGen;
>
> typedef row_matrix<SubTwoDGen, SubMatIndexerGen> submatrix_type;
># 643 "/usr/local/include/mtl/matrix_implementation.h" 3
> inline submatrix_type sub_matrix(size_type row_start, size_type row_finish,
> size_type col_start, size_type col_finish) const
> {
> dim_type starts = Base::indexer.at(dim_type(row_start, col_start));
> size_type m = row_finish - row_start;
> size_type n = col_finish - col_start;
> typedef typename TwoD::is_strided IsStrided;
> if (IsStrided::id) {
> return submatrix_type((value_type*)Base::twod.data()
> + starts.second() * Base::twod.ld() + starts.first(),
> m, n, Base::twod.ld());
> } else {
> return submatrix_type((value_type*)Base::twod.data()
> + starts.first() * Base::twod.ld() + starts.second(),
> m, n, Base::twod.ld());
> }
> }
># 688 "/usr/local/include/mtl/matrix_implementation.h" 3
>};
>
>
>
>
>
>
>
>template <class TwoDGen, class IndexerGen>
>class column_matrix : public matrix_implementation<TwoDGen, IndexerGen> {
> typedef matrix_implementation<TwoDGen, IndexerGen> Base;
>public:
> typedef typename Base::pointer pointer;
> typedef typename Base::reference reference;
> typedef typename Base::const_reference const_reference;
> typedef typename Base::value_type value_type;
> typedef typename Base::size_type size_type;
> typedef typename Base::dim_type dim_type;
> typedef typename Base::dyn_dim dyn_dim;
> typedef typename Base::band_type band_type;
> typedef typename Base::TwoD TwoD;
> typedef typename Base::OneD OneD;
> typedef typename Base::OneDRef OneDRef;
> typedef typename Base::Indexer Indexer;
> typedef OneD Column;
> typedef OneDRef ColumnRef;
> enum { M = Indexer::M, N = Indexer::N };
> typedef row_matrix<TwoDGen,
> typename IndexerGen::transpose_type> transpose_type;
> typedef row_matrix<typename TwoDGen::transpose_type,
> typename IndexerGen::strided_type> strided_type;
>
> typedef column_matrix<typename TwoDGen::banded_view_type,
> gen_banded_indexer<typename IndexerGen::orienter,M,N,size_type> > banded_view_type;
># 740 "/usr/local/include/mtl/matrix_implementation.h" 3
> inline column_matrix() { }
>
>
> inline column_matrix(size_type m, size_type n)
> : Base(dim_type(m, n)) { }
> inline column_matrix(size_type m, size_type n, size_type nnz_max)
> : Base(dim_type(m, n), nnz_max) { }
> inline column_matrix(size_type m, size_type n, int sub, int super)
> : Base(dim_type(m, n),
> band_type(sub, super)) { }
>
> inline column_matrix& operator=(const column_matrix& x) {
> Base::operator=(x);
> return *this;
> }
>
> inline column_matrix(pointer data, size_type m, size_type n)
> : Base(data, dim_type(m, n), char()) { }
> inline column_matrix(pointer data, size_type m, size_type n, size_type ld)
> : Base(data, dim_type(m, n), ld) { }
>
>
> inline column_matrix(pointer data, size_type m, size_type n,
> size_type ld, dyn_dim starts)
> : Base(data, dim_type(m, n), ld, starts, char()) { }
>
> inline column_matrix(pointer data, size_type m, size_type n,
> int sub, int super)
> : Base(data, dim_type(m, n),
> band_type(sub, super)) { }
> inline column_matrix(pointer data, size_type m, size_type n, size_type ld,
> int sub, int super)
> : Base(data, dim_type(m, n), ld,
> band_type(sub, super)) { }
>
>
> inline column_matrix(pointer data)
> : Base(data) { }
>
>
> template <class Matrix>
> inline column_matrix(int sub, int super, const Matrix& x)
> : Base(x, band_type(sub, super)) { }
>
>
> template <class Matrix, class ST, int BM, int BN>
> inline column_matrix(const Matrix& x, mtl::dimension<ST,BM,BN> bdim)
> : Base(x, bdim, char()) { }
>
>
>
> inline column_matrix(size_type m, size_type n, size_type nnz,
> pointer val, size_type* ptrs, size_type* inds)
> : Base(dim_type(m, n), nnz, val, ptrs, inds) { }
>
>
> typedef matrix_market_stream<value_type> mmstream;
> typedef harwell_boeing_stream<value_type> hbstream;
> inline column_matrix(mmstream& m_in) : Base(m_in, *this) { }
> inline column_matrix(mmstream& m_in, int sub, int super)
> : Base(m_in, band_type(sub,super), *this) { }
> inline column_matrix(hbstream& m_in) : Base(m_in, *this) { }
> inline column_matrix(hbstream& m_in, int sub, int super)
> : Base(m_in, band_type(sub,super), *this) { }
>
> template <class Subclass>
> inline column_matrix(mmstream & m_in, Subclass& s) : Base(m_in, s) { }
> template <class Subclass>
> inline column_matrix(hbstream & m_in, Subclass& s) : Base(m_in, s) { }
> template <class Subclass>
> inline column_matrix(mmstream& m_in, int sub, int super, Subclass& s)
> : Base(m_in, band_type(sub, super), s) { }
> template <class Subclass>
> inline column_matrix(hbstream& m_in, int sub, int super, Subclass& s)
> : Base(m_in, band_type(sub, super), s) { }
>
>
> inline column_matrix(const column_matrix& x)
> : Base(x) { }
>
>
> inline column_matrix(const column_matrix& x, do_strided)
> : Base(x) { }
>
>
> inline column_matrix(const transpose_type& x, do_transpose t)
> : Base(x, t, t) { }
>
>
> inline column_matrix(const strided_type& x, do_strided s)
> : Base(x, s, s) { }
>
>
> template <class MatrixT, class ScalarT>
> inline column_matrix(const MatrixT& x, const ScalarT& y, do_scaled s)
> : Base(x, y, s) { }
>
> inline column_matrix(const TwoD& x, Indexer ind)
> : Base(x, ind) { }
>
> inline ~column_matrix() { }
>
> inline void resize(size_type m, size_type n) {
> Base::twod.resize(n, m);
> Base::indexer.dim = dim_type(n, m);
> }
>
>
>
> typedef typename TwoDGen::submatrix_type SubTwoDGen;
> typedef typename SubTwoDGen::type::size_type new_sizeT;
>
>
>
> typedef typename IndexerGen:: template bind<new_sizeT>::other SubMatIndexerGen;
>
> typedef column_matrix<SubTwoDGen, SubMatIndexerGen> submatrix_type;
># 866 "/usr/local/include/mtl/matrix_implementation.h" 3
> inline submatrix_type sub_matrix(size_type row_start, size_type row_finish,
> size_type col_start, size_type col_finish) const
> {
> dim_type starts = Base::indexer.at(dim_type(row_start, col_start));
> size_type m = row_finish - row_start;
> size_type n = col_finish - col_start;
> typedef typename TwoD::is_strided IsStrided;
> if (IsStrided::id) {
> return submatrix_type((value_type*)Base::twod.data()
> + starts.second() * Base::twod.ld() + starts.first(),
> m, n, Base::twod.ld());
> } else {
> return submatrix_type((value_type*)Base::twod.data()
> + starts.first() * Base::twod.ld() + starts.second(),
> m, n, Base::twod.ld());
> }
> }
># 912 "/usr/local/include/mtl/matrix_implementation.h" 3
>};
>
>template <class Matrix>
>struct rows_type {
> typedef typename Matrix::orientation orien;
> enum { orienid = orien::id };
> typedef typename IF<EQUAL<orienid,ROW_MAJOR>::RET,
> Matrix, typename Matrix::strided_type>::RET type;
>};
>
>template <class Matrix>
>struct columns_type {
> typedef typename Matrix::orientation orien;
> enum { orienid = orien::id };
> typedef typename IF<EQUAL<orienid,COL_MAJOR>::RET,
> Matrix, typename Matrix::strided_type>::RET type;
>};
># 939 "/usr/local/include/mtl/matrix_implementation.h" 3
>template<class Matrix>
>inline typename rows_type<Matrix>::type
>rows(const Matrix& A) {
> return rows_type<Matrix>::type(A, do_strided());
>}
># 954 "/usr/local/include/mtl/matrix_implementation.h" 3
>template<class Matrix>
>inline typename columns_type<Matrix>::type
>columns(const Matrix& A) {
> return columns_type<Matrix>::type(A, do_strided());
>}
># 970 "/usr/local/include/mtl/matrix_implementation.h" 3
>template <class Matrix>
>inline typename Matrix::transpose_type
>trans(const Matrix& A) {
> typedef typename Matrix::transpose_type Trans;
> return Trans(A, do_transpose());
>}
># 984 "/usr/local/include/mtl/matrix_implementation.h" 3
>template <class TwoDGen, class IndexerGen>
>class diagonal_matrix : public matrix_implementation<TwoDGen, IndexerGen> {
> typedef matrix_implementation<TwoDGen, IndexerGen> Base;
> typedef diagonal_matrix self;
>public:
> typedef typename Base::pointer pointer;
> typedef typename Base::reference reference;
> typedef typename Base::value_type value_type;
> typedef typename Base::size_type size_type;
> typedef typename Base::dim_type dim_type;
> typedef typename Base::dyn_dim dyn_dim;
> typedef typename Base::band_type band_type;
> typedef typename Base::TwoD TwoD;
> typedef typename Base::OneD OneD;
> typedef typename Base::OneDRef OneDRef;
> typedef typename Base::Indexer Indexer;
> typedef typename Base::const_reference const_reference;
>
>
> typedef OneD Diagonal;
> typedef OneDRef DiagonalRef;
> typedef diagonal_tag shape;
>
> typedef diagonal_matrix<TwoDGen,
> typename IndexerGen::transpose_type> transpose_type;
>
>
>
>
>
>
> typedef row_matrix<typename TwoDGen::transpose_type,
> typename IndexerGen::strided_type> strided_type;
>
> inline diagonal_matrix() { }
>
>
> inline diagonal_matrix(size_type m, size_type n)
> : Base(dim_type(m, n)) { }
> inline diagonal_matrix(size_type m, size_type n,
> int sub, int super)
> : Base(dim_type(m, n), band_type(sub, super)) { }
>
>
> inline diagonal_matrix(pointer d, size_type m, size_type n)
> : Base(d, dim_type(m, n)) { }
> inline diagonal_matrix(pointer d, size_type m, size_type n,
> int sub, int super)
> : Base(d, dim_type(m, n), band_type(sub, super)) { }
>
> typedef matrix_market_stream<value_type> mmstream;
> typedef harwell_boeing_stream<value_type> hbstream;
>
>
> inline diagonal_matrix(mmstream& m_in) : Base(m_in) { }
>
>
> inline diagonal_matrix(hbstream& m_in) : Base(m_in) { }
>
>
> inline diagonal_matrix(const self& x)
> : Base(x) { }
>
>
> inline diagonal_matrix(const self& x, do_strided s)
> : Base(x) { }
>
>
> inline diagonal_matrix(const transpose_type& x, do_transpose t)
> : Base(x, t, t) { }
>
>
> inline diagonal_matrix(const strided_type& x, do_strided s)
> : Base(x, s, s) { }
>
>
> template <class MatrixT, class ScalarT>
> inline diagonal_matrix(const MatrixT& x, const ScalarT& y, do_scaled s)
> : Base(x, y, s) { }
>
> inline ~diagonal_matrix() { }
>};
>
>
>
>template <class Base_, class Uplo>
>class triangle_matrix : public Base_ {
> typedef Base_ Base;
> Uplo uplo;
>public:
> typedef typename Base::pointer pointer;
> typedef typename Base::reference reference;
> typedef typename Base::value_type value_type;
> typedef typename Base::size_type size_type;
> typedef typename Base::dim_type dim_type;
> typedef typename Base::dyn_dim dyn_dim;
> typedef typename Base::band_type band_type;
> typedef typename Base::TwoD TwoD;
> typedef typename Base::OneD OneD;
> typedef typename Base::OneDRef OneDRef;
> typedef typename Base::Indexer Indexer;
> typedef typename Base::orien orien;
> typedef typename Base::const_reference const_reference;
>
> typedef triangle_tag shape;
>
> typedef typename Uplo::transpose_type Uplotrans;
> typedef triangle_matrix<typename Base::transpose_type,
> Uplotrans> transpose_type;
>
> typedef triangle_matrix<typename Base::strided_type, Uplo> strided_type;
>
>
> inline triangle_matrix() { }
>
> inline triangle_matrix(size_type m, size_type n)
> : Base(m, n,
> uplo.bandwidth(m-1,n-1).first,
> uplo.bandwidth(m-1,n-1).second) { }
>
>
> inline triangle_matrix(pointer d, size_type m, size_type n)
> : Base(d, m, n,
> uplo.bandwidth(m-1, n-1).first,
> uplo.bandwidth(m-1, n-1).second) { }
>
>
> inline triangle_matrix(size_type m, size_type n, int uplo_)
> : Base(m, n, Uplo::bandwidth(uplo_, m, n)) , uplo(uplo_) { }
>
>
> inline triangle_matrix(pointer d, size_type m, size_type n, int uplo_)
> : Base(d, m, n,
> Uplo::bandwidth(uplo_, m-1, n-1).first,
> Uplo::bandwidth(uplo_, m-1, n-1).second) { }
>
>
> inline triangle_matrix(pointer d, size_type m, size_type n,
> int sub, int super)
> : Base(d, m, n,
> uplo.bandwidth(sub,super).first,
> uplo.bandwidth(sub,super).second) { }
>
>
> template <class Matrix>
> inline triangle_matrix(const Matrix& x)
> : Base(uplo.bandwidth(x.nrows()-1, x.ncols()-1).first,
> uplo.bandwidth(x.nrows()-1, x.ncols()-1).second, x) { }
>
>
> inline triangle_matrix(const transpose_type& x, do_transpose t)
> : Base(x, t) { }
>
>
> inline triangle_matrix(const strided_type& x, do_strided s)
> : Base(x, s) { }
>
> inline triangle_matrix(const triangle_matrix& x, do_strided)
> : Base(x) { }
>
>
> typedef matrix_market_stream<value_type> mmstream;
> typedef harwell_boeing_stream<value_type> hbstream;
> inline triangle_matrix(mmstream& m_in)
> : Base(m_in,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).first,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).second,
> *this) { }
> inline triangle_matrix(hbstream& m_in)
> : Base(m_in,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).first,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).second,
> *this) { }
>
>
> template <class MatrixT, class ScalarT>
> inline triangle_matrix(const MatrixT& x, const ScalarT& y, do_scaled s)
> : Base(x, y, s) { }
>
> inline ~triangle_matrix() { }
>
> inline bool is_upper() const { return uplo.is_upper(); }
> inline bool is_lower() const { return ! uplo.is_upper(); }
> inline bool is_unit() const { return uplo.is_unit(); }
>
>};
>
>
>
>
>template <class Base_, class Uplo>
>class symmetric_matrix : public Base_ {
> typedef Base_ Base;
> Uplo uplo;
>public:
> typedef typename Base::pointer pointer;
> typedef typename Base::reference reference;
> typedef typename Base::value_type value_type;
> typedef typename Base::size_type size_type;
> typedef typename Base::dim_type dim_type;
> typedef typename Base::dyn_dim dyn_dim;
> typedef typename Base::band_type band_type;
> typedef typename Base::TwoD TwoD;
> typedef typename Base::OneD OneD;
> typedef typename Base::OneDRef OneDRef;
> typedef typename Base::Indexer Indexer;
> typedef typename Base::orien orien;
> typedef typename Base::const_reference const_reference;
>
> typedef symmetric_tag shape;
>
> typedef typename Uplo::transpose_type Uplotrans;
> typedef symmetric_matrix<typename Base::transpose_type,
> Uplotrans> transpose_type;
>
> typedef symmetric_matrix<typename Base::strided_type, Uplo> strided_type;
>
> inline symmetric_matrix() { }
>
> inline symmetric_matrix(size_type n)
> : Base(n, n,
> uplo.bandwidth(n-1,n-1).first,
> uplo.bandwidth(n-1,n-1).second) { }
> inline symmetric_matrix(size_type n, int sub)
> : Base(n, n,
> uplo.bandwidth(sub,sub).first,
> uplo.bandwidth(sub,sub).second) { }
>
>
> inline symmetric_matrix(pointer d, size_type n)
> : Base(d, n, n,
> uplo.bandwidth(n-1,n-1).first,
> uplo.bandwidth(n-1,n-1).second) { }
>
>
> inline symmetric_matrix(size_type n, int uplo_, int sub)
> : Base(n, n, Uplo::bandwidth(uplo_, sub, sub)) , uplo(uplo_) { }
>
>
> inline symmetric_matrix(pointer d, size_type n, int uplo_, int sub)
> : Base(d, n, n,
> Uplo::bandwidth(uplo_, sub, sub).first,
> Uplo::bandwidth(uplo_, sub, sub).second) { }
>
>
> inline symmetric_matrix(size_type m, size_type n, size_type nnz,
> pointer val, size_type* ptrs, size_type* inds)
> : Base(m, n, nnz, val, ptrs, inds) { }
>
>
> inline symmetric_matrix(pointer d, size_type n, int sub)
> : Base(d, n, n,
> uplo.bandwidth(sub,sub).first,
> uplo.bandwidth(sub,sub).second) { }
>
> inline symmetric_matrix(const transpose_type& x, do_transpose t)
> : Base(x, t) { }
>
> inline symmetric_matrix(const strided_type& x, do_strided s)
> : Base(x, s) { }
>
> typedef matrix_market_stream<value_type> mmstream;
> typedef harwell_boeing_stream<value_type> hbstream;
> inline symmetric_matrix(mmstream& m_in)
> : Base(m_in,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).first,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).second,
> *this) { }
> inline symmetric_matrix(hbstream& m_in)
> : Base(m_in,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).first,
> uplo.bandwidth(m_in.nrows()-1,m_in.ncols()-1).second,
> *this) { }
>
> template <class MatrixT, class ScalarT>
> inline symmetric_matrix(const MatrixT& x, const ScalarT& y, do_scaled s)
> : Base(x, y, s) { }
>
> inline ~symmetric_matrix() { }
>
> inline bool is_upper() const { return uplo.is_upper(); }
> inline bool is_lower() const { return ! uplo.is_upper(); }
>
>
> inline reference
> operator()(size_type row, size_type col) {
> if (uplo.is_upper()) {
> if (col > row)
> return Base::operator()(row, col);
> else
> return Base::operator()(col, row);
> } else {
> if (row > col)
> return Base::operator()(row, col);
> else
> return Base::operator()(col, row);
> }
> }
>
> inline const_reference
> operator()(size_type row, size_type col) const {
> if (uplo.is_upper()) {
> if (col > row)
> return Base::operator()(row, col);
> else
> return Base::operator()(col, row);
> } else {
> if (row > col)
> return Base::operator()(row, col);
> else
> return Base::operator()(col, row);
> }
> }
>
>
> inline int sub() const {
> return std::max(Base::indexer.super(),Base::indexer.sub());
> }
> inline int super() const {
> return std::max(Base::indexer.super(),Base::indexer.sub());
> }
>
>};
>
>
>
>
>
>}
># 34 "/usr/local/include/mtl/matrix.h" 2 3
># 1 "/usr/local/include/mtl/rect_indexer.h" 1 3
># 22 "/usr/local/include/mtl/rect_indexer.h" 3
>namespace mtl {
>
>
>template <class size_type, class Orien, int MM, int NN>
>class rect_indexer {
>public:
> enum { M = MM, N = NN };
> typedef dimension<size_type, M, N> dim_type;
> typedef dimension<size_type> dyn_dim;
>
> typedef dimension<int> band_type;
>
>
> dim_type dim;
>
> typedef typename Orien::orientation orientation;
> typedef rectangle_tag shape;
>
> typedef rect_indexer<size_type,
> typename Orien::transpose_type, MM, NN> transpose_type;
> typedef rect_indexer<size_type,
> typename Orien::transpose_type, NN, MM> strided_type;
>
>
>
> typedef Orien orienter;
>
> class OneDIndexer {
> public:
> inline OneDIndexer() { }
> inline OneDIndexer(size_type majornum) : major_num(majornum) { }
> inline OneDIndexer(const OneDIndexer& x) : major_num(x.major_num) { }
>
> template <class OneDIterator> inline
> size_type row(OneDIterator i) const { return Orien::row(coords(i)); }
>
> template <class OneDIterator> inline
> size_type column(OneDIterator i) const { return Orien::column(coords(i)); }
>
> template <class OneDIterator> inline
> size_type minor(OneDIterator i) const { return coords(i).second(); }
>
> template <class OneDIterator> inline
> OneDIterator begin(OneDIterator i) const { return i; }
>
> inline size_type at(size_type i) const { return i; }
> protected:
> template <class OneDIterator> inline
> dyn_dim coords(OneDIterator i) const {
> return dyn_dim(major_num, i.index());
> }
> size_type major_num;
> };
> inline rect_indexer() { }
> inline rect_indexer(dim_type d) : dim(d) { }
> inline rect_indexer(dim_type d, band_type) : dim(d) { }
> inline rect_indexer(const rect_indexer& x) : dim(x.dim) { }
>
>
> template <class Indexer>
> inline rect_indexer(const Indexer& x) : dim(x.dim) { }
>
>
>
>
>
>
>
> inline rect_indexer(const strided_type& x, strideable)
> : dim(x.dim.transpose()) { }
>
> inline rect_indexer(const transpose_type& x, not_strideable)
> : dim(x.dim) { }
>
> template <class TwoDIterator> inline
> OneDIndexer deref(TwoDIterator i) const { return OneDIndexer(i.index()); }
>
> inline OneDIndexer deref(size_type i) const {
> return OneDIndexer(i);
> }
># 110 "/usr/local/include/mtl/rect_indexer.h" 3
> template <class Dim> inline
> Dim at(Dim p) const { return Orien::map(p); }
>
>
> inline static dim_type twod_dim(dim_type dim) { return dim; }
> inline static dim_type twod_dim(dim_type dim, band_type) { return dim; }
>
> inline static band_type twod_band(dim_type , band_type bw) { return bw; }
>
> inline size_type nrows() const{ return Orien::row(dim); }
> inline size_type ncols() const { return Orien::column(dim); }
>
> inline int sub() const { return nrows() - 1; }
> inline int super() const { return ncols() - 1; }
>
>};
>
>
>
>template <class Orien, int MM, int NN, class size_type>
>struct gen_rect_indexer {
>
>
>
>
>
>
> enum { M = MM, N = NN };
>
> typedef dimension<char, M, N> twod_dim_type;
>
> typedef gen_rect_indexer< typename Orien::transpose_type, MM, NN, size_type>
> transpose_type;
> typedef gen_rect_indexer< typename Orien::transpose_type, NN, MM, size_type>
> strided_type;
>
> typedef rect_indexer<size_type, Orien, M, N> type;
>
> template <class ST>
> struct bind {
> typedef gen_rect_indexer<Orien, MM, NN, ST> other;
> };
>
> typedef Orien orienter;
>};
>
>}
># 35 "/usr/local/include/mtl/matrix.h" 2 3
>
># 1 "/usr/local/include/mtl/diagonal_indexer.h" 1 3
>
>
>
>
>
>
>namespace mtl {
>
>template <class size_type, class Orien>
>class diagonal_indexer {
>public:
>
> enum { M = 0, N = 0 } ;
>
> typedef dimension<size_type> dim_type;
> typedef dimension<int> band_type;
>
> dim_type dim;
> band_type bandwidth;
>
> typedef typename Orien::orientation orientation;
> typedef diagonal_tag shape;
>
> typedef diagonal_indexer<size_type,
> typename Orien::transpose_type> transpose_type;
> typedef diagonal_indexer<size_type,
> typename Orien::transpose_type> strided_type;
>
> typedef Orien orienter;
>
> class OneDIndexer {
> public:
> inline OneDIndexer() { }
> inline OneDIndexer(size_type majornum, dim_type s)
> : major_num(majornum), starts(s) { }
> inline OneDIndexer(const OneDIndexer& x)
> : major_num(x.major_num), starts(x.starts) { }
>
> template <class OneDIterator> inline
> size_type row(OneDIterator i) const { return Orien::row(coords(i)); }
>
> template <class OneDIterator> inline
> size_type column(OneDIterator i) const{ return Orien::column(coords(i)); }
>
> template <class OneDIterator> inline
> size_type minor(OneDIterator i) const { return coords(i).second(); }
>
> template <class OneDIterator> inline
> OneDIterator begin(OneDIterator i) const { return i; }
> protected:
> template <class OneDIterator> inline
> dim_type coords(OneDIterator i) const {
> return dim_type(i.index() + starts.first(),
> i.index() + starts.second());
> }
> size_type major_num;
> dim_type starts;
> };
> inline diagonal_indexer() { }
> inline diagonal_indexer(dim_type d, band_type band)
> : dim(d), bandwidth(band) { }
> inline diagonal_indexer(const diagonal_indexer& x)
> : dim(x.dim), bandwidth(x.bandwidth) { }
> inline diagonal_indexer(const strided_type& x, strideable)
> : dim(x.dim.transpose()), bandwidth(x.bandwidth) { }
> inline diagonal_indexer(const transpose_type& x, not_strideable)
> : dim(x.dim), bandwidth(x.bandwidth) { }
>
> template <class TwoDIterator> inline
> OneDIndexer deref(TwoDIterator iter) const {
> int row = std::max(0,int(iter.index()) - bandwidth.second());
> int col = std::max(0,bandwidth.second() - int(iter.index()));
> return OneDIndexer(iter.index(), dim_type(row, col));
> }
>
> OneDIndexer deref(size_type i) const {
> int row = std::max(0,int(i) - bandwidth.second());
> int col = std::max(0,bandwidth.second() - int(i));
> return OneDIndexer(i, dim_type(row, col));
> }
>
> inline dim_type at(dim_type p) const {
> dim_type m = Orien::map(p);
> int i = m.first(); int j = m.second();
> int ii = i - j + bandwidth.second();
> if (i >= j)
> return dim_type(ii, j);
> else
> return dim_type(ii, i);
> }
>
>
>
>
> inline static dim_type twod_dim(dim_type dim, band_type bw) {
> return dim_type(bw.first() + bw.second() + 1,
> std::min(dim.first(),dim.second() + bw.first()));
> }
>
>
>
>
> inline static band_type twod_band(dim_type dim, band_type bw) {
> return band_type(bw.second(), std::min(dim.first()- 1,dim.second() - bw.second() - 1));
>
> }
>
> inline size_type nrows() const{ return Orien::row(dim); }
> inline size_type ncols() const { return Orien::column(dim); }
>
> inline int sub() const { return Orien::row(bandwidth); }
> inline int super() const { return Orien::column(bandwidth); }
>
>};
>
>
>
>template <class Orien, int MM, int NN, class size_type>
>struct gen_diagonal_indexer {
> typedef dimension<char,0,0> twod_dim_type;
> typedef gen_diagonal_indexer< typename Orien::transpose_type, NN, MM, size_type>
> transpose_type;
> typedef gen_diagonal_indexer< Orien, -1, -1,char> strided_type;
>
> typedef diagonal_indexer<size_type, Orien> type;
> typedef Orien orienter;
> template <class ST>
> struct bind {
> typedef gen_diagonal_indexer<Orien, MM, NN, ST> other;
> };
>};
>
>}
># 37 "/usr/local/include/mtl/matrix.h" 2 3
>
># 1 "/usr/local/include/mtl/dense2D.h" 1 3
># 17 "/usr/local/include/mtl/dense2D.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 18 "/usr/local/include/mtl/dense2D.h" 2 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 20 "/usr/local/include/mtl/dense2D.h" 2 3
>
>
>
>
># 1 "/usr/local/include/mtl/strided1D.h" 1 3
># 18 "/usr/local/include/mtl/strided1D.h" 3
># 1 "/usr/local/include/mtl/strided_iterator.h" 1 3
># 17 "/usr/local/include/mtl/strided_iterator.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 18 "/usr/local/include/mtl/strided_iterator.h" 2 3
>
>
>
>namespace mtl {
># 36 "/usr/local/include/mtl/strided_iterator.h" 3
>template <class RandomAccessIterator, int isConst>
>class strided_iterator {
> typedef strided_iterator self;
>public:
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::difference_type
> difference_type;
>
>
>
>
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::value_type
> value_type;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::iterator_category
> iterator_category;
>
>
> typedef typename std::iterator_traits<RandomAccessIterator>::reference
> reference;
>
> typedef typename std::iterator_traits<RandomAccessIterator>::pointer
> pointer;
>
>
>
>
>
> typedef difference_type Distance;
>
> typedef RandomAccessIterator iterator_type;
>
>
> inline strided_iterator() : stride(0), pos(0) { }
>
>
> inline strided_iterator(const RandomAccessIterator& x, int s, int p)
> : iter(x), stride(s), pos(p) { }
>
>
> inline strided_iterator(const self& x)
> : iter(x.iter), stride(x.stride), pos(x.pos) { }
>
>
> inline self& operator=(const self& x) {
> iter = x.iter; stride = x.stride; pos = x.pos; return *this;
> }
>
>
>
> inline int index() const { return iter.index() / stride; }
>
>
> inline operator RandomAccessIterator () const { return iter; }
>
> inline RandomAccessIterator base() const { return iter; }
>
>
> inline reference operator*() const { return *iter; }
>
>
> inline self& operator++ (){
> ++pos; iter += stride; return *this;
> }
>
> inline self operator++ (int){
> self tmp = *this; ++pos; iter += stride; return tmp;
> }
>
> inline self& operator-- (){
> --pos; iter -= stride; return *this;
> }
>
> inline self operator-- (int){
> self tmp = *this; --pos; iter -= stride; return tmp;
> }
>
> inline self operator+ (Distance n) const {
> return self (iter + n*stride, stride, pos + n);
> }
>
> inline self& operator+= (Distance n) {
> iter += n*stride; pos += n; return *this;
> }
>
> inline self operator- (Distance n) const {
> return self (iter - n*stride, stride, pos - n);
> }
>
> inline self& operator-= (Distance n) {
> iter -= n*stride; pos -= n; return *this;
> }
>
>
> inline self operator+ (const self& x) const {
> return self(iter + x.iter, stride, pos + x.pos);
> }
>
> inline Distance operator- (const self& x) const { return iter - x.iter; }
>
> inline reference operator[] (Distance n) const { return *(*this+n*stride); }
>
> inline bool operator==(const self& x) const { return pos == x.pos; }
>
> inline bool operator!=(const self& x) const { return pos != x.pos; }
>
> inline bool operator<(const self& x) const { return pos < x.pos; }
>protected:
> RandomAccessIterator iter;
> int stride;
> int pos;
>};
># 160 "/usr/local/include/mtl/strided_iterator.h" 3
>}
># 19 "/usr/local/include/mtl/strided1D.h" 2 3
>
>
>
>
>namespace mtl {
># 38 "/usr/local/include/mtl/strided1D.h" 3
>template <class RandomAccessContainerRef>
>class strided1D {
> typedef RandomAccessContainerRef Vector;
> typedef strided1D<Vector> self;
>public:
>
> enum { N = RandomAccessContainerRef::N };
>
>
>
>
> typedef typename Vector::value_type value_type;
>
>
> typedef typename Vector::reference reference;
>
>
> typedef typename Vector::const_reference const_reference;
>
>
> typedef strided_iterator<typename Vector::iterator,0> iterator;
>
>
> typedef strided_iterator<typename Vector::const_iterator,1> const_iterator;
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
> typedef scaled1D<self> scaled_type;
>
> typedef typename Vector::sparsity sparsity;
>
> typedef typename Vector::IndexArrayRef IndexArrayRef;
>
> typedef typename Vector::IndexArray IndexArray;
>
> typedef typename Vector::dimension dimension;
>
>
>
> typedef typename Vector::size_type size_type;
>
>
> typedef typename Vector::difference_type difference_type;
>
> typedef typename Vector::pointer pointer;
>
> typedef strided1D<typename Vector::subrange_type> subrange_type;
>
>
>
>
> inline strided1D(const Vector& r, int stride_)
> : rep(r), stride(stride_),
> start(stride_ < 0 ? (r.size() + stride_) : 0),
> n(rep.size()/ std::abs(stride_))
> { }
>
>
> inline strided1D(const self& x)
> : rep(x.rep), stride(x.stride), start(x.start), n(x.n) { }
>
> inline self& operator=(const self& x) {
> rep = x.rep; stride = x.stride; start = x.start; n = x.n;
> return *this;
> }
>
> inline operator Vector&() { return rep; }
>
>
>
>
> inline iterator begin() {
> typename Vector::iterator i = rep.begin();
> i += start;
> return iterator(i, stride, 0);
> }
>
>
> inline iterator end() {
> typename Vector::iterator i = rep.end();
> i -= start;
> return iterator(i, stride, n);
> }
>
>
> inline const_iterator begin() const {
> typename Vector::const_iterator i = rep.begin();
> i += start;
> return const_iterator(i, stride, 0);
> }
>
>
> inline const_iterator end() const {
> typename Vector::const_iterator i = rep.end();
> i -= start;
> return const_iterator(i, stride, n);
> }
>
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
> inline reference operator[](size_type i) { return *(begin() + i); }
>
>
> inline const_reference operator[](size_type i) const {
> return rep[i * stride];
> }
>
>
> inline size_type size() const { return rep.size() / stride; }
>
>
> inline size_type nnz() const { return rep.nnz(); }
>
>
> inline subrange_type operator()(size_type s, size_type f) const {
> return subrange_type(rep(s*stride, f*stride), stride);
> }
>
> inline self& adjust_index(size_type i) {
> rep.adjust_index(i);
> return *this;
> }
>
>protected:
> Vector rep;
> int stride;
> size_type start, n;
>};
>
>
>
>
>
>
>
>template <class RandomAccessContainerRef, class Distance>
>inline strided1D<RandomAccessContainerRef>
>strided(RandomAccessContainerRef v, Distance stride_)
>{
> return strided1D<RandomAccessContainerRef>(v,stride_);
>}
>
>
>}
># 25 "/usr/local/include/mtl/dense2D.h" 2 3
># 34 "/usr/local/include/mtl/dense2D.h" 3
>namespace mtl {
>
>template <class size_t, int MM, int NN>
>class strided_offset;
>
>
>struct strided_tag { enum { id = 1 }; };
>struct not_strided_tag { enum { id = 0 }; };
>
>template <class size_t, int MM, int NN>
>class band_view_offset;
>
>template <class size_t, int MM, int NN>
>class strided_band_view_offset;
>
>template <int M, int N> struct gen_rect_offset;
>template <int M, int N> struct gen_strided_offset;
>template <int M, int N> struct gen_banded_offset;
>template <int M, int N> struct gen_banded_view_offset;
>template <int M, int N> struct gen_strided_band_view_offset;
>template <int M, int N> struct gen_packed_offset;
>
>
>
>
>
>
>template <class size_t, int MM, int NN>
>class rect_offset {
>public:
>
> template <class Vec>
> struct bind_oned {
> typedef Vec type;
> };
>
> typedef not_strided_tag is_strided;
> typedef size_t size_type;
> enum { M = MM, N = NN, IS_STRIDED = 0 };
> typedef dimension<size_type, MM, NN> dim_type;
> typedef dimension<int> band_type;
> typedef strided_offset<size_type, MM, NN> transpose_type;
> typedef strideable strideability;
>
>
>
>
>
> inline rect_offset() : dim(0,0), ld(0) { }
> inline rect_offset(const rect_offset& x) : dim(x.dim), ld(x.ld) { }
> inline rect_offset(size_type m, size_type n, size_type ld_)
> : dim(m, n), ld(ld_) { }
> inline rect_offset(size_type m, size_type n, size_type ld_, band_type)
> : dim(m, n), ld(ld_) { }
> rect_offset(const transpose_type& x);
> inline rect_offset& operator=(const rect_offset& x) {
> dim = x.dim; ld = x.ld; return *this;
> }
> inline size_type elt(size_type i, size_type j) const { return i * ld + j; }
> inline size_type oned_offset(size_type i) const { return i * ld; }
> inline size_type oned_length(size_type) const { return dim.second(); }
> inline size_type twod_length() const { return dim.first(); }
> inline size_type stride() const { return 1; }
> inline static size_type size(size_type m, size_type n,
> size_type , size_type) { return m * n; }
> inline size_type major() const { return dim.first(); }
> inline size_type minor() const { return dim.second(); }
>
> dim_type dim;
> size_type ld;
>};
>
>
>
>
>template <int M, int N>
>struct gen_rect_offset {
>
>
>
> template <class size_type>
> struct bind {
> typedef rect_offset<size_type, M, N> type;
> };
>
> typedef gen_strided_offset<M,N> transpose_type;
> typedef gen_banded_view_offset<M,N> banded_view_type;
>
>};
>
>
>
>
>
>template <class size_t, int MM, int NN>
>class strided_offset {
>public:
>
> template <class Vec>
> struct bind_oned {
> typedef strided1D<Vec> type;
> };
>
>
>
> typedef strided_tag is_strided;
> enum { M = MM, N = NN, IS_STRIDED = 1 };
> typedef size_t size_type;
> typedef dimension<size_type, MM, NN> dim_type;
> typedef dimension<int> band_type;
> typedef rect_offset<size_type,MM,NN> transpose_type;
> typedef strideable strideability;
>
>
> inline strided_offset() : dim(0,0), ld(0) { }
> inline strided_offset(size_type m, size_type n, size_type ld_)
> : dim(m, n), ld(ld_) { }
> inline strided_offset(const transpose_type& x) : dim(x.dim), ld(x.ld) { }
> inline strided_offset& operator=(const strided_offset& x) {
> dim = x.dim; ld = x.ld; return *this;
> }
> inline size_type elt(size_type i, size_type j) const { return j * ld + i; }
> inline size_type oned_offset(size_type i) const { return i; }
> inline size_type oned_length(size_type) const { return dim.first() * ld; }
> inline size_type twod_length() const { return dim.second(); }
> inline size_type stride() const { return ld; }
> inline static size_type size(size_type m, size_type n,
> size_type , size_type) { return m * n; }
> inline size_type major() const { return dim.first(); }
> inline size_type minor() const { return dim.second(); }
>
> dim_type dim;
> size_type ld;
>};
>
>
>
>template <int M, int N>
>struct gen_strided_offset {
>
>
>
> template <class size_type>
> struct bind {
> typedef strided_offset<size_type, M, N> type;
> };
>
> typedef gen_rect_offset<M,N> transpose_type;
> typedef gen_strided_band_view_offset<M,N> banded_view_type;
>};
>
>template <class size_t, int MM, int NN>
>inline rect_offset<size_t,MM,NN>::rect_offset(const rect_offset<size_t,MM,NN>::transpose_type& x)
> : dim(x.dim), ld(x.ld) { }
>
>
>
>
>
>
>
>template <class size_t, int MM, int NN>
>class banded_view_offset {
>public:
>
> template <class Vec>
> struct bind_oned {
> typedef Vec type;
> };
>
>
> typedef not_strided_tag is_strided;
> enum { M = MM, N = NN, IS_STRIDED = 0 };
> typedef size_t size_type;
> typedef dimension<size_type, MM, NN> dim_type;
> typedef dimension<int, MM, NN> band_type;
> typedef strided_band_view_offset<size_type, MM, NN> transpose_type;
>
> typedef not_strideable strideability;
>
>
> inline banded_view_offset()
> : dim(0,0), ld(0), bw(std::make_pair(0,0)) { }
> inline banded_view_offset(size_type m, size_type n, size_type leading_dim,
> band_type band)
> : dim(m, n), ld(leading_dim), bw(band) { }
> inline banded_view_offset(size_type m, size_type n, size_type leading_dim)
> : dim(m, n), ld(leading_dim), bw(band_type(0,0)) { }
>
> template <class Offset>
> inline banded_view_offset(Offset os, band_type band)
> : dim(os.dim), ld(os.ld), bw(band) { }
>
> inline banded_view_offset& operator=(const banded_view_offset& x) {
> dim = x.dim; ld = x.ld; bw = x.bw; return *this;
> }
>
> inline size_type elt(size_type i, size_type j) const {
> size_type start = std::max(int(i) - bw.first(),0);
> return i * ld + j + start;
> }
> inline size_type oned_offset(size_type i) const {
> size_type start = std::max(int(i) - bw.first(),0);
> return i * ld + start;
> }
> inline size_type oned_length(size_type i) const {
> return std::max(0,std::min(int(dim.second()),int(i) + bw.second() + 1) - std::max(0,int(i) - bw.first()));
>
> }
> inline size_type twod_length() const { return dim.first(); }
> inline int stride() const { return 1; }
> inline static size_type size(size_type m, size_type n,
> size_type , size_type) {
> return m * n;
> }
> inline size_type major() const { return dim.first(); }
> inline size_type minor() const { return dim.second(); }
>
>
> dim_type dim;
> size_type ld;
> band_type bw;
>};
>
>
>
>
>template <int M, int N>
>struct gen_banded_view_offset {
>
>
>
> template <class size_type>
> struct bind {
> typedef banded_view_offset<size_type, M, N> type;
> };
>
> typedef gen_strided_band_view_offset<M,N> transpose_type;
> typedef gen_banded_view_offset<M,N> banded_view_type;
>};
># 284 "/usr/local/include/mtl/dense2D.h" 3
>template <class size_t, int MM, int NN>
>class strided_band_view_offset {
>public:
>
> template <class Vec>
> struct bind_oned {
> typedef strided1D<Vec> type;
> };
>
> typedef strided_tag is_strided;
> enum { M = MM, N = NN, IS_STRIDED = 1 };
> typedef size_t size_type;
> typedef dimension<size_type, MM, NN> dim_type;
> typedef dimension<int, MM, NN> band_type;
> typedef banded_view_offset<size_type, MM, NN> transpose_type;
>
> typedef not_strideable strideability;
>
>
> inline strided_band_view_offset()
> : dim(0,0), ld(0), bw(std::make_pair(0,0)) { }
> inline strided_band_view_offset(size_type m, size_type n,
> size_type leading_dim,
> band_type band)
> : dim(m, n), ld(leading_dim), bw(band) { }
>
> template <class Offset>
> inline strided_band_view_offset(Offset os, band_type band)
> : dim(os.dim), ld(os.ld), bw(band) { }
>
> inline strided_band_view_offset&
> operator=(const strided_band_view_offset& x) {
> dim = x.dim; ld = x.ld; bw = x.bw; return *this;
> }
>
> inline size_type elt(size_type i, size_type j) const {
> size_type start = std::max(int(i) - bw.first(),0);
> return (j + start) * ld + i;
> }
> inline size_type oned_offset(size_type i) const {
> size_type start = std::max(int(i) - bw.first(),0);
> return start * ld + i;
> }
> inline size_type oned_length(size_type i) const {
>
> size_type len = std::max(0,std::min(int(dim.first()),int(i) + bw.second() + 1) - std::max(0,int(i) - bw.first()));
>
> return len * ld;
> }
> inline size_type twod_length() const { return dim.second(); }
> inline int stride() const { return ld; }
> inline static size_type size(size_type m, size_type n,
> size_type , size_type) {
> return m * n;
> }
> inline size_type major() const { return dim.first(); }
> inline size_type minor() const { return dim.second(); }
>
>
> dim_type dim;
> size_type ld;
> band_type bw;
>};
>
>
>
>
>template <int M, int N>
>struct gen_strided_band_view_offset {
>
>
>
> template <class size_type>
> struct bind {
> typedef strided_band_view_offset<size_type, M, N> type;
> };
>
> typedef gen_banded_view_offset<M,N> transpose_type;
> typedef gen_strided_band_view_offset<M,N> banded_view_type;
>};
>
>
>template <class size_t, int MM, int NN>
>class packed_offset;
>
>
>
>
>
>
>
>template <class size_t, int MM, int NN>
>class banded_offset {
>public:
>
> template <class Vec>
> struct bind_oned {
> typedef Vec type;
> };
>
> typedef not_strided_tag is_strided;
> enum { M = MM, N = NN, IS_STRIDED = 0 };
> typedef size_t size_type;
> typedef dimension<size_type, MM, NN> dim_type;
> typedef dimension<int> band_type;
> typedef packed_offset<size_type,MM,NN> transpose_type;
> typedef not_strideable strideability;
> inline banded_offset()
> : dim(0,0), bw(band_type(0,0)), ndiag(0) { }
>
> inline banded_offset(size_type m, size_type n, size_type ,
> band_type band)
> : dim(m,n), bw(band), ndiag(band.first() + band.second() + 1) { }
>
> inline banded_offset(size_type m, size_type n, size_type )
> : dim(m,n), bw(band_type(0,0)), ndiag(0) { }
>
> inline banded_offset& operator=(const banded_offset& x) {
> dim = x.dim; ndiag = x.ndiag; bw = x.bw; return *this;
> }
> inline size_type elt(size_type i, size_type j) const {
> return this->oned_offset(i) + j;
> }
> inline size_type oned_offset(size_type i) const {
> return i * ndiag + std::max(0,bw.first() - int(i));
> }
> inline size_type oned_length(size_type i) const {
> return std::max(0,std::min(int(dim.second()),int(i) + bw.second() + 1) - std::max(0,int(i) - bw.first()));
>
> }
> inline size_type twod_length() const { return dim.first(); }
>
> inline int stride() const { return 1; }
>
> inline static size_type size(size_type m, size_type n,
> size_type low, size_type up) {
>
>
> return (low + up + 1) * std::min(m,n + low);
> }
> inline size_type major() const { return dim.first(); }
> inline size_type minor() const { return dim.second(); }
>private:
> dim_type dim;
> band_type bw;
> size_type ndiag;
>};
>
>
>
>
>template <int M, int N>
>struct gen_banded_offset {
>
>
>
> template <class size_type>
> struct bind {
> typedef banded_offset<size_type, M, N> type;
> };
>
> typedef gen_packed_offset<M,N> transpose_type;
> typedef gen_banded_view_offset<M,N> banded_view_type;
>};
>
>
>
>
>
>
>
>template <class size_t, int MM, int NN>
>class packed_offset {
>public:
>
> template <class Vec>
> struct bind_oned {
> typedef Vec type;
> };
>
> typedef not_strided_tag is_strided;
> enum { M = MM, N = NN, IS_STRIDED = 0 };
> typedef size_t size_type;
> typedef dimension<size_type, MM, NN> dim_type;
> typedef dimension<int> band_type;
> typedef banded_offset<size_type, MM, NN> transpose_type;
> typedef not_strideable strideability;
> inline packed_offset()
> : dim(0,0), bw(band_type(0,0)) { }
>
> inline packed_offset(size_type m, size_type n, size_type ,
> band_type bandwidth)
> : dim(m,n), bw(bandwidth) { }
>
> inline packed_offset& operator=(const packed_offset& x) {
> dim = x.dim; bw = x.bw; return *this;
> }
> inline int elt(size_type i, size_type j) const {
> return this->oned_offset(i) + j;
> }
>
> inline int calc_low(int i, int low) const {
> int l = std::min(low,int(i));
> int lower_area = low * i;
> lower_area -= ( - l*l + 2*low*l + l) / 2;
> return lower_area;
> }
> inline int calc_up(int i, int up) const {
> int upper_area = up * i;
> int n = i + up - dim.second();
> if (n > 0) {
> int n1 = std::max(n - up,0);
> int n2 = n - n1;
> upper_area -= n1 * up;
> upper_area -= ((n2 + 1) * n2) / 2;
> }
> return upper_area;
> }
>
> inline int oned_offset(size_type i) const {
> int low = bw.first();
> int up = bw.second();
> int upper_area, lower_area;
>
> if (up < -1)
> upper_area = - calc_low(i, - (up + 1));
> else if (up > 0)
> upper_area = calc_up(i, up);
> else
> upper_area = 0;
>
> if (low < -1)
> lower_area = - calc_up(i, - (low + 1));
> else if (low > 0)
> lower_area = calc_low(i, low);
> else
> lower_area = 0;
>
> size_type diagonal_len;
> if (up < 0 || low < 0)
> diagonal_len = 0;
> else
> diagonal_len = std::min(std::min(i,dim.first()),dim.second());
>
> size_type ret = upper_area + lower_area + diagonal_len;
> return ret;
> }
>
> inline int stride() const { return 1; }
>
> inline size_type oned_length(size_type i) const {
> return std::max(0,std::min(int(dim.second()),int(i) + bw.second() + 1) - std::max(0,int(i) - bw.first()));
>
> }
> inline size_type twod_length() const { return dim.first(); }
>
> inline static size_type size(int m, int n, int low, int up) {
> packed_offset offset(m, n, n, band_type(low, up));
> return offset.oned_offset(m);
> }
> inline size_type major() const { return dim.first(); }
> inline size_type minor() const { return dim.second(); }
>
>private:
> dim_type dim;
> band_type bw;
>};
>
>
>
>template <int M, int N>
>struct gen_packed_offset {
>
>
>
> template <class size_type>
> struct bind {
> typedef packed_offset<size_type, M, N> type;
> };
>
> typedef gen_banded_offset<M,N> transpose_type;
> typedef gen_banded_view_offset<M,N> banded_view_type;
>};
># 575 "/usr/local/include/mtl/dense2D.h" 3
>template <int isConst, class T, class Offset, class InnerOneD, class OneD>
>class dense2D_iterator {
>public:
> typedef typename Offset::size_type size_type;
> typedef std::pair<size_type,size_type> pair_type;
>
> typedef typename IF<isConst, const T*,T*>::RET Iterator;
>
> typedef dense2D_iterator self;
>
> typedef int distance_type;
> typedef int difference_type;
>
> typedef std::random_access_iterator_tag iterator_category;
>
> typedef OneD* pointer;
> typedef OneD value_type;
> typedef OneD reference;
> typedef difference_type Distance;
> typedef Iterator iterator_type;
>
>protected:
>
> Iterator start;
> size_type pos;
> size_type ld;
> pair_type starts;
> Offset offset;
>public:
>
> inline size_type index() const { return pos + starts.second; }
>
> inline dense2D_iterator () {}
>
> inline dense2D_iterator(const self& x)
> : start(x.start), pos(x.pos),
> ld(x.ld), starts(x.starts), offset(x.offset) { }
>
> inline self& operator=(const self& x) {
> start = x.start;
> pos = x.pos;
> ld = x.ld;
> starts = x.starts;
> offset = x.offset;
> return *this;
> }
>
> inline explicit
> dense2D_iterator(Iterator x, size_type ld_, size_type p, pair_type s,
> Offset os)
> : start(x), pos(p), ld(ld_), starts(s), offset(os) { }
>
> inline Iterator base () const { return start + pos; }
>
> inline reference deref(Distance pos, not_strided_tag) const {
> return reference((T*)start + offset.oned_offset(pos),
> offset.oned_length(pos),
> starts.first);
> }
> inline reference deref(Distance pos, strided_tag) const {
> InnerOneD vec((T*)start + offset.oned_offset(pos),
> offset.oned_length(pos),
> starts.first);
> return strided(vec, offset.stride());
> }
> inline reference operator*() const {
> typedef typename Offset::is_strided Strided;
> return deref(pos, Strided());
> }
> inline reference operator[] (Distance n) const {
> typedef typename Offset::is_strided Strided;
> return deref(pos + n, Strided());
> }
>
>
>
>
>
> inline self& operator++ () { ++pos; return *this; }
> inline self operator++ (int) { self tmp = *this; ++pos; return tmp; }
> inline self& operator-- () { --pos; return *this; }
> inline self operator-- (int) { self tmp = *this; --pos; return tmp; }
> inline self& operator+=(size_type n) { pos += n; return *this; }
> inline self operator+(size_type n) const {
> return self(start, ld, pos + n, starts);
> }
> inline self& operator-=(size_type n) { pos -= n; return *this; }
>
>
>
>};
>
>template <int isConst, class T, class Offset, class InnerOneD, class OneD>
>inline typename dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>::difference_type
>operator-(const dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>& x,
> const dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>& y)
>{
> return x.index() - y.index();
>}
>
>template <int isConst,class T, class Offset, class InnerOneD, class OneD>
>inline bool
>operator== (const dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>& x,
> const dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>& y)
>{
> return x.index() == y.index();
>}
>
>template <int isConst, class T, class Offset, class InnerOneD, class OneD>
>inline bool
>operator!= (const dense2D_iterator<isConst, T,Offset,InnerOneD,OneD>& x,
> const dense2D_iterator<isConst, T,Offset,InnerOneD,OneD>& y)
>{
> return x.index() != y.index();
>}
>
>template <int isConst,class T, class Offset, class InnerOneD, class OneD>
>inline bool
>operator< (const dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>& x,
> const dense2D_iterator<isConst,T,Offset,InnerOneD,OneD>& y)
>{
> return x.index() < y.index();
>}
>
>
>
>
>
>
>
>template <class Strided>
>struct __bracket { };
>
>template <>
>struct __bracket<strided_tag> {
> template <class OneD, class InnerOneD, class elt_type, class size_type>
> inline OneD
> operator()(elt_type* d, size_type len, size_type f, size_type ld,
> const OneD*, const InnerOneD*) {
> InnerOneD vec(d , len, f);
> return OneD(vec, ld);
> }
>};
>
>template <>
>struct __bracket<not_strided_tag> {
> template <class OneD, class InnerOneD, class elt_type, class size_type>
> inline OneD
> operator()(elt_type* d, size_type len, size_type f, size_type,
> const OneD*, const InnerOneD*) {
> return OneD(d, len, f);
> }
>};
>
>
>
>template<class T, class OffsetGen, int MM, int NN>
>class dense2D;
>
>template <class T, class OffsetGen, int MM, int NN>
>class external2D;
># 765 "/usr/local/include/mtl/dense2D.h" 3
>template <class RepType, class RepPtr, class OffsetGen, int MM, int NN>
>class generic_dense2D {
>public:
>
> enum { M = MM, N = NN };
>
>
> typedef typename RepType::size_type size_type;
>
> typedef typename RepType::difference_type difference_type;
>
>protected:
> typedef std::pair<size_type,size_type> pair_type;
> typedef RepType reptype;
> typedef RepPtr rep_ptr;
> typedef typename RepType::value_type elt_type;
>
>
>
>
>
> typedef typename OffsetGen:: template bind<size_type>::type Offset;
>
>
> typedef dimension<elt_type> dyn_dim;
>public:
>
> typedef typename Offset::dim_type dim_type;
>
>
> typedef typename Offset::band_type band_type;
>
>
>
>
> typedef dense_tag sparsity;
>
> typedef typename Offset::is_strided is_strided;
>
>protected:
> typedef external_vec<elt_type, N> InnerOneD;
>
>
>
>
>
> typedef typename Offset:: template bind_oned<InnerOneD>::type OneD;
>
>
> typedef OneD OneDRef;
> typedef OneD ConstOneDRef;
>public:
>
>
> typedef OneD value_type;
>
> typedef value_type reference;
>
> typedef value_type const_reference;
>
>
> typedef dense2D_iterator<0,elt_type, Offset, InnerOneD, OneD> iterator;
>
>
> typedef dense2D_iterator<1,elt_type, Offset, InnerOneD, OneD> const_iterator;
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
> typedef generic_dense2D<RepType, RepPtr,
> typename OffsetGen::transpose_type, MM, NN> transpose_type;
>
>
> typedef generic_dense2D<RepType, RepPtr,
> typename OffsetGen::banded_view_type, MM, NN> banded_view_type;
>
>
> typedef external2D<elt_type, OffsetGen, MM, NN> submatrix_type;
># 856 "/usr/local/include/mtl/dense2D.h" 3
> typedef typename Offset::strideability strideability;
>
>
>
>
> inline generic_dense2D()
> : ld_(0), data_(0), starts(std::make_pair(0,0)) { }
>
>
> inline generic_dense2D(rep_ptr data, size_type m, size_type n, size_type ld)
> : ld_(ld), data_(data),
> starts(std::make_pair(0,0)), offset(m, n, ld) { }
>
>
> inline generic_dense2D(rep_ptr data, size_type m, size_type n,
> size_type ld, dyn_dim s, char)
> : ld_(ld), data_(data),
> starts(std::make_pair(s.first(),s.second())), offset(m, n, ld) { }
>
>
> inline generic_dense2D(rep_ptr data, size_type ld)
> : ld_(ld), data_(data),
> starts(std::make_pair(0,0)), offset(M, N, ld) { }
>
>
> inline generic_dense2D(rep_ptr data, size_type m, size_type n, size_type ld,
> band_type bw)
> : ld_(ld), data_(data), starts(std::make_pair(0,0)),
> offset(m, n, ld, bw) { }
>
>
>
>
> inline generic_dense2D(const generic_dense2D& x)
> : ld_(x.ld_), data_(x.data_), starts(x.starts),
> offset(x.offset) { }
>
>
> inline generic_dense2D& operator=(const generic_dense2D& x) {
> ld_ = x.ld_; data_ = x.data_; starts = x.starts; offset = x.offset;
> return *this;
> }
>
>
> inline generic_dense2D(rep_ptr d, const generic_dense2D& x)
> : ld_(x.ld_), data_(d), starts(x.starts), offset(x.offset) { }
>
>
> inline generic_dense2D(const transpose_type& x, do_transpose, do_transpose)
> : ld_(x.ld_), data_(x.data_), starts(x.starts), offset(x.offset) { }
>
>
>
>
>
>
> template <class MatrixStream, class Orien>
> inline generic_dense2D(rep_ptr data, MatrixStream& s, Orien)
> : ld_(Orien::map(dim_type(s.nrows(),s.ncols())).second()),
> data_(data),
> starts(std::make_pair(0,0)),
> offset(Orien::map(dim_type(s.nrows(),s.ncols())).first(),
> Orien::map(dim_type(s.nrows(),s.ncols())).second(),
> Orien::map(dim_type(s.nrows(),s.ncols())).second()) { }
>
> template <class MatrixStream, class Orien>
> inline generic_dense2D(rep_ptr data, MatrixStream& s,
> Orien, band_type bw)
> : ld_(Orien::map(dim_type(s.nrows(),s.ncols())).second()),
> data_(data),
> starts(std::make_pair(0,0)),
> offset(Orien::map(dim_type(s.nrows(),s.ncols())).first(),
> Orien::map(dim_type(s.nrows(),s.ncols())).second(),
> Orien::map(dim_type(s.nrows(),s.ncols())).second(),
> bw) { }
>
>
> template <class TwoD>
> inline generic_dense2D(rep_ptr data, const TwoD& x, band_type bw, banded_tag)
> : ld_(x.ld_),
> data_(data),
> starts(x.starts),
> offset(x.offset, bw) { }
>
>
>
>
>
> inline ~generic_dense2D() { }
>
>
>
>
>
>
>
> inline iterator begin() {
> return iterator(data(), ld_, 0, starts, offset);
> }
>
> inline iterator end() {
> return iterator(data(), ld_, offset.twod_length(), starts, offset);
> }
>
> inline const_iterator begin() const {
> return const_iterator(data(), ld_, 0, starts, offset);
> }
>
> inline const_iterator end() const {
> return const_iterator(data(), ld_, offset.twod_length(),
> starts, offset);
> }
>
>
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
>
> inline const elt_type& operator()(size_type i, size_type j) const {
> return *(data() + offset.elt(i, j));
> }
>
> inline elt_type& operator()(size_type i, size_type j) {
> return *(data() + offset.elt(i, j));
> }
>
>
>
>
> inline size_type nnz() const { return offset.major() * offset.minor(); }
>
>
> inline size_type capacity() const { return offset.major() * offset.minor(); }
>
>
> inline size_type major() const { return offset.major(); }
>
>
> inline size_type minor() const { return offset.minor(); }
>
>
> inline size_type ld() const { return ld_; }
>
>
> inline const elt_type* data() const { return &(*data_)[0]; }
> inline elt_type* data() { return &(*data_)[0]; }
># 1030 "/usr/local/include/mtl/dense2D.h" 3
> inline OneD operator[](size_type i) const {
> typedef OneD* oned_ptr;
> typedef InnerOneD* inner_oned_ptr;
> return __bracket<is_strided>()((elt_type*)data() + offset.oned_offset(i),
> offset.oned_length(i),
> starts.first, ld_,
> oned_ptr(),
> inner_oned_ptr());
> }
># 1084 "/usr/local/include/mtl/dense2D.h" 3
> size_type ld_;
> rep_ptr data_;
> pair_type starts;
> Offset offset;
>};
>
>
>template <class T, class OffsetGen, int M, int N>
>struct gen_dense2D;
># 1112 "/usr/local/include/mtl/dense2D.h" 3
>template<class T, class OffsetGen, int MM = 0, int NN = 0>
>class dense2D
> : public generic_dense2D< std::vector<T> ,
> refcnt_ptr< std::vector<T> >, OffsetGen, MM, NN >
>
>
>
>{
>public:
> typedef generic_dense2D< std::vector<T> ,
> refcnt_ptr< std::vector<T> >, OffsetGen, MM, NN> super;
>
>
>
> typedef typename super::Offset Offset;
>
> typedef typename Offset::dim_type dim_type;
>
> typedef typename Offset::band_type band_type;
> typedef typename super::reptype reptype;
> typedef typename super::rep_ptr rep_ptr;
>
> typedef typename super::size_type size_type;
>
> typedef dense2D<T, typename OffsetGen::transpose_type,
> MM, NN> transpose_type;
>
>
>
> typedef internal_tag storage_loc;
>
>
> inline dense2D() { }
>
>
> inline dense2D(dim_type dim)
> : super(new reptype(Offset::size(dim.first(), dim.second(), 0, 0)),
> dim.first(),
> dim.second(),
> dim.second()) { }
>
>
> inline dense2D(dim_type dim, band_type bw)
> : super(new reptype(Offset::size(dim.first(),dim.second(),
> bw.first(), bw.second())),
> dim.first(),
> dim.second(),
> dim.second(),
> bw) { }
>
>
> inline dense2D(const dense2D& x)
> : super(x) { }
>
>
> inline dense2D& operator=(const dense2D& x) {
> super::operator=(x);
> return *this;
> }
>
>
> inline dense2D(const transpose_type& x, do_transpose t, do_transpose)
> : super(x, t, t) { }
>
>
>
>
> template <class MatrixStream, class Orien>
> inline dense2D(MatrixStream& s, Orien)
> : super(new reptype(Offset::size(Orien::map(dim_type(s.nrows(),
> s.ncols())).first(),
> Orien::map(dim_type(s.nrows(),
> s.ncols())).second(),
> 0, 0)),
> s,
> Orien()) { }
>
>
> template <class MatrixStream, class Orien>
> inline dense2D(MatrixStream& s, Orien, band_type bw)
> : super(new reptype(Offset::size(Orien::map(dim_type(s.nrows(),
> s.ncols())).first(),
> Orien::map(dim_type(s.nrows(),
> s.ncols())).second(),
> bw.first(), bw.second())),
> s,
> Orien(),
> bw) { }
># 1213 "/usr/local/include/mtl/dense2D.h" 3
> template <class TwoD>
> inline dense2D(const TwoD& x, band_type bw, banded_tag)
> : super(x.data_, x, bw, banded_tag()) { }
>
>
>
> inline ~dense2D() { }
>
> inline void resize(size_type m, size_type n) {
> rep_ptr newdata = new reptype(Offset::size(m, n, 0, 0));
> size_type i, j;
> size_type M = std::min(m,super::offset.major());
> size_type N = std::min(n,super::offset.minor());
> for (i = 0; i < M; ++i)
> for (j = 0; j < N; ++j)
> (*newdata)[i * n + j] = (*this)(i,j);
> for (; i < m; ++i)
> for (; j < n; ++j)
> (*newdata)[i * n + j] = T();
>
> super::data_ = newdata;
> super::ld_ = n;
> super::offset.dim = dim_type(m, n);
> super::offset.ld = n;
> }
>
>};
>
>template <class T, class OffsetGen, int M, int N>
>struct gen_external2D;
># 1251 "/usr/local/include/mtl/dense2D.h" 3
>template <class T, class OffsetGen, int M, int N>
>struct gen_dense2D {
> typedef gen_dense2D<T, typename OffsetGen::transpose_type,N,M> transpose_type;
> typedef gen_external2D<T, OffsetGen,M,N> submatrix_type;
># 1263 "/usr/local/include/mtl/dense2D.h" 3
> typedef gen_dense2D<T, typename OffsetGen::banded_view_type,M,N>
> banded_view_type;
>
> typedef dense2D<T, OffsetGen, M, N> type;
>};
># 1282 "/usr/local/include/mtl/dense2D.h" 3
>template <class T, class OffsetGen, int MM = 0, int NN = 0>
>class external2D
> : public generic_dense2D< external_vec<T,NN>,
> external_vec<T,NN>*, OffsetGen, MM, NN >
>{
> typedef generic_dense2D< external_vec<T,NN>,
> external_vec<T,NN>*, OffsetGen, MM, NN > super;
>public:
> external_vec<T,NN> rep;
> typedef dimension<T> dyn_dim;
> typedef typename super::Offset Offset;
>
> typedef typename Offset::dim_type dim_type;
>
> typedef typename Offset::band_type band_type;
>
> typedef typename super::reptype reptype;
>
>
> typedef typename super::size_type size_type;
>
> typedef external2D<T, typename OffsetGen::transpose_type,
> MM, NN> transpose_type;
>
>
>
> typedef external_tag storage_loc;
>
>
> inline external2D() { }
>
>
> inline external2D(T* data, dim_type dim)
> : super(&rep, dim.first(), dim.second(), dim.second()),
> rep(data, dim.first() * dim.second())
> { }
>
>
> inline external2D(T* data, dim_type dim, size_type ld)
> : super(&rep, dim.first(), dim.second(), ld),
> rep(data, dim.first() * ld)
> { }
>
>
> inline external2D(T* data, dim_type dim, size_type ld,
> dyn_dim s, char)
> : super(&rep, dim.first(), dim.second(), ld, s, char()),
> rep(data, dim.first() * ld)
> { }
>
>
> inline external2D(T* data, dim_type dim, band_type bw)
> : super(&rep, dim.first(), dim.second(), dim.second(), bw),
> rep(data, dim.first() * dim.second())
> { }
>
> inline external2D(T* data, dim_type dim, size_type ld, band_type bw)
> : super(&rep, dim.first(), dim.second(), ld, bw),
> rep(data, dim.first() * ld)
> { }
>
>
> inline external2D(const external2D& x)
> : super(&rep, x), rep(x.rep)
> { }
>
>
> inline external2D& operator=(const external2D& x) {
> rep = x.rep;
> super::operator=(x);
> super::data_ = &rep;
> return *this;
> }
>
>
> inline external2D(const transpose_type& x, do_transpose t, do_transpose)
> : super(x, t, t), rep(x.rep) { }
># 1377 "/usr/local/include/mtl/dense2D.h" 3
> template <class TwoD>
> inline external2D(const TwoD& x, band_type bw, banded_tag)
> : super(&rep, x, bw, banded_tag()), rep((T*)x.data(), x.major() * x.ld()) { }
>
>
> inline ~external2D() { }
># 1391 "/usr/local/include/mtl/dense2D.h" 3
>};
>
>
>
>template <class T, class OffsetGen, int M, int N>
>struct gen_external2D {
> typedef gen_external2D<T, typename OffsetGen::transpose_type, N, M> transpose_type;
> typedef gen_external2D<T, OffsetGen,M,N> submatrix_type;
> typedef gen_external2D<T, typename OffsetGen::banded_view_type,M,N>
> banded_view_type;
># 1409 "/usr/local/include/mtl/dense2D.h" 3
> typedef external2D<T, OffsetGen, M, N> type;
>};
>
>
>
>}
># 39 "/usr/local/include/mtl/matrix.h" 2 3
># 1 "/usr/local/include/mtl/array2D.h" 1 3
># 24 "/usr/local/include/mtl/array2D.h" 3
># 1 "/usr/local/include/mtl/utils.h" 1 3
># 21 "/usr/local/include/mtl/utils.h" 3
># 1 "/usr/local/include/mtl/mtl_complex.h" 1 3
># 22 "/usr/local/include/mtl/utils.h" 2 3
>
>
>
>namespace mtl {
>
>
>using std::complex;
>
>
>
>
>template <class Vector>
>inline void
>print_partitioned_vector(Vector x)
>{
> for (typename Vector::iterator i = x.begin();
> i != x.end(); ++i) {
> print_vector(*i);
> }
>}
>
>template <class Matrix>
>inline void
>print_partitioned_matrix(const Matrix& A)
>{
> std::cout << "Top mat: " << A.nrows() << "x" << A.ncols() << std::endl;
> typedef typename mtl::matrix_traits<Matrix>::size_type Int;
> Int i,j;
> for (i=0; i < A.nrows(); ++i) {
> for (j=0; j < A.ncols(); ++j)
> print_all_matrix( A(i,j) );
> std::cout << std::endl;
> }
>}
>
>template <class Matrix>
>inline void
>print_partitioned_by_row(const Matrix& A)
>{
> std::cout << "Top mat: " << A.nrows() << "x" << A.ncols() << std::endl;
> typename Matrix::const_iterator A_kk;
> typename Matrix::Row::const_iterator A_i, A_iend;
> A_kk = A.begin();
> while (not_at(A_kk, A.end())) {
> A_i = (*A_kk).begin();
> A_iend = (*A_kk).end();
> while (not_at(A_i, A_iend)) {
> print_all_matrix( *A_i );
> ++A_i;
> }
> ++A_kk;
> }
>}
>
>template <class Matrix>
>inline void
>print_partitioned_by_column(const Matrix& A)
>{
> std::cout << "Top mat: " << A.nrows() << "x" << A.ncols() << std::endl;
> typename Matrix::const_iterator A_kk;
> typename Matrix::Column::const_iterator A_i, A_iend;
> A_kk = A.begin();
> while (not_at(A_kk, A.end())) {
> A_i = (*A_kk).begin();
> A_iend = (*A_kk).end();
> while (not_at(A_i, A_iend)) {
> print_all_matrix( *A_i );
> ++A_i;
> }
> ++A_kk;
> }
>}
>
>
>
>
>template <class size_type>
>dimension<size_type>
>calc_start_fini(int i, int minor, dimension<size_type> bandwidth)
>{
> int start = std::max(i - int(bandwidth.first()),0);
> int fini = std::min(i + int(bandwidth.second()) + 1,minor);
> if (start > fini) start = fini;
> return dimension<size_type>(start,fini);
>}
>
>
>template <class Iterator>
>inline void
>print_vector(Iterator y, Iterator y_end)
>{
> std::cout << "[";
> while (not_at(y, y_end)) {
> std::cout << *y << ",";
> ++y;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Vector>
>inline void
>print_vector(Vector x)
>{
> typename Vector::iterator i = x.begin();
> std::cout << "[";
> while (not_at(i, x.end())) {
> std::cout << *i << ",";
> ++i;
> }
> std::cout << "]" << std::endl;
>}
>
>template <class Vector>
>inline void
>print_vector_index(Vector x)
>{
> typename Vector::iterator i = x.begin();
> std::cout << "[";
> while (not_at(i, x.end())) {
> std::cout << i.index() << ",";
> ++i;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>inline void
>print_coord(const Matrix& A)
>{
> typename Matrix::const_iterator A_kk;
> typename Matrix::OneD::const_iterator A_i;
> A_kk = A.begin();
> while (not_at(A_kk, A.end())) {
> A_i = (*A_kk).begin();
> while (not_at(A_i, (*A_kk).end())) {
> std::cout << "(" << A_kk.row() << "," << A_i.column() << ") = " << *A_i << std::endl;
> ++A_i;
> }
> ++A_kk;
> }
>}
>
>
>template <class Matrix>
>inline void
>print_all_matrix(const Matrix& A)
>{
> typedef typename matrix_traits<Matrix>::size_type Int;
> Int i,j;
> std::cout << A.nrows() << "x" << A.ncols() << std::endl;
> std::cout << "[" << std::endl;
> for (i=0; i < A.nrows(); ++i) {
> std::cout << "[";
> for (j=0; j < A.ncols(); ++j) {
> std::cout << A(i,j);
> if (j < A.ncols() - 1)
> std::cout << ",";
> }
> std::cout << "]";
> if (i < A.nrows() - 1)
> std::cout << "," << std::endl;
> else
> std::cout << std::endl;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>inline void
>print_all_banded(const Matrix& A, int lo, int up)
>{
> typedef typename matrix_traits<Matrix>::size_type Int;
> Int i, j;
> std::cout << A.nrows() << "x" << A.ncols() << std::endl;
> std::cout << "[" << std::endl;
> for (i = 0; i < A.nrows(); ++i) {
> Int first = std::max(0,int(i) - lo);
> Int last = std::min(int(A.ncols()),int(i) + up + 1);
> std::cout << "[";
> for (j = 0; j < A.ncols(); ++j) {
> if (j < first || j >= last)
> std::cout << 0;
> else {
> std::cout << A(i,j);
> }
> if (j < A.ncols() - 1)
> std::cout << ",";
> }
> std::cout << "]";
> if (i < A.nrows() - 1)
> std::cout << "," << std::endl;
> else
> std::cout << std::endl;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>void print_minor(const Matrix& A)
>{
> typename Matrix::const_minor_iterator A_kk;
> typename Matrix::MinorVector::const_iterator A_i;
> A_kk = A.begin_minor();
> std::cout << "[" << std::endl;
> while (not_at(A_kk, A.end_minor())) {
> std::cout << "[";
> A_i = (*A_kk).begin();
> while (not_at(A_i, (*A_kk).end())) {
> std::cout << *A_i;
> ++A_i;
> std::cout << ",";
> }
> std::cout << "]";
> std::cout << "," << std::endl;
> ++A_kk;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>void print_row(const Matrix& A)
>{
> typename Matrix::const_iterator A_kk;
> typename Matrix::Row::const_iterator A_i, A_iend;
> A_kk = A.begin();
> std::cout << "[" << std::endl;
> while (not_at(A_kk, A.end())) {
> std::cout << "[";
> A_i = (*A_kk).begin();
> A_iend = (*A_kk).end();
> while (not_at(A_i, A_iend)) {
> std::cout << *A_i;
> ++A_i;
> std::cout << ",";
> }
> std::cout << "]";
> std::cout << "," << std::endl;
> ++A_kk;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>void print_rev_row(const Matrix& A)
>{
> typename Matrix::const_reverse_iterator A_kk;
> typename Matrix::Row::const_reverse_iterator A_i;
> typename Matrix::Row::const_reverse_iterator A_iend;
> A_kk = A.rbegin();
> std::cout << "[" << std::endl;
> while (not_at(A_kk, A.rend())) {
> std::cout << "[";
> A_i = (*A_kk).rbegin();
> A_iend = (*A_kk).rend();
> while (not_at(A_i, A_iend)) {
> std::cout << *A_i;
> ++A_i;
> std::cout << ",";
> }
> std::cout << "]";
> std::cout << "," << std::endl;
> ++A_kk;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>void print_column(const Matrix& A)
>{
> typename Matrix::const_iterator A_kk;
> typename Matrix::Column::const_iterator A_i;
> A_kk = A.begin();
> std::cout << "[" << std::endl;
> while (not_at(A_kk, A.end())) {
> std::cout << "[";
> A_i = (*A_kk).begin();
> while (not_at(A_i, (*A_kk).end())) {
> std::cout << *A_i;
> ++A_i;
> std::cout << ",";
> }
> std::cout << "]";
> std::cout << "," << std::endl;
> ++A_kk;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>void print_rev_column(const Matrix& A)
>{
> typename Matrix::const_reverse_iterator A_kk;
> typename Matrix::Column::const_reverse_iterator A_i;
> A_kk = A.rbegin();
> std::cout << "[" << std::endl;
> while (not_at(A_kk, A.rend())) {
> std::cout << "[";
> A_i = (*A_kk).rbegin();
> while (not_at(A_i, (*A_kk).rend())) {
> std::cout << *A_i;
> ++A_i;
> std::cout << ",";
> }
> std::cout << "]";
> std::cout << "," << std::endl;
> ++A_kk;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class Matrix>
>void print_major(const Matrix& A)
>{
> typename Matrix::const_iterator A_kk;
> typename Matrix::OneD::const_iterator A_i;
> A_kk = A.begin();
> std::cout << "[" << std::endl;
> while (not_at(A_kk, A.end())) {
> std::cout << "[";
> A_i = (*A_kk).begin();
> while (not_at(A_i, (*A_kk).end())) {
> std::cout << *A_i;
> ++A_i;
> std::cout << ",";
> }
> std::cout << "]";
> std::cout << "," << std::endl;
> ++A_kk;
> }
> std::cout << "]" << std::endl;
>}
>
>
>template <class MatrixA, class MatrixB>
>inline bool
>matrix_equal(const MatrixA& A, const MatrixB& B)
>{
> typedef typename matrix_traits<MatrixA>::size_type Int;
> if (A.nrows() != Int(B.nrows()) || A.ncols() != Int(B.ncols()))
> return false;
>
> for (Int i = 0; i < A.nrows(); ++i)
> for (Int j = 0; j < A.ncols(); ++j)
> if (A(i,j) != B(i,j)) {
>
> std::cout << "(" < << A(i,j) << " != " << B(i,j) << std::endl;
>
> return false;
> }
>
> return true;
>}
># 459 "/usr/local/include/mtl/utils.h" 3
>inline float
>make_rand_element(float)
>{
> float r = float(rand());
> return r/float(2147483647)*10.0;
>}
>
>inline double
>make_rand_element(double)
>{
> double r = double(rand());
> return r/double(2147483647)*10.0L;
>}
>
>inline complex<float>
>make_rand_element(complex<float>)
>{
> return complex<float>(make_rand_element(float()),
> make_rand_element(float()));
>}
>
>inline complex<double>
>make_rand_element(complex<double>)
>{
> return complex<double>(make_rand_element(double()),
> make_rand_element(double()));
>}
># 565 "/usr/local/include/mtl/utils.h" 3
>template <class Mat>
>inline void
>insert_zero_matrix(Mat& A)
>{
> typedef typename matrix_traits<Mat>::size_type Int;
>
>
> Int i, j;
> for (i = 0; i < A.nrows(); ++i) {
> Int first = std::max(0,int(i) - int(A.sub()));
> Int last = std::min(int(A.ncols()),int(i) + int(A.super()) + 1);
> for (j = 0; j < A.ncols(); ++j)
> if (j >= first && j < last)
> A(i,j) = 0.0;
> }
>
>}
>
>template <class Matrix>
>inline void
>zero_matrix(Matrix& A){
> typedef typename matrix_traits<Matrix>::value_type T;
> typename Matrix::iterator oneD_iter = A.begin();
> while (oneD_iter < A.end()) {
> typename Matrix::OneD::iterator i = (*oneD_iter).begin();
> while (i < (*oneD_iter).end()) {
> *i = T(0);
> ++i;
> }
> ++oneD_iter;
> }
>}
># 665 "/usr/local/include/mtl/utils.h" 3
>}
># 25 "/usr/local/include/mtl/array2D.h" 2 3
>
>
>
>namespace mtl {
>
>template <class T>
>struct gen_array2D;
># 61 "/usr/local/include/mtl/array2D.h" 3
>template <class OneD_>
>class array2D {
> typedef array2D<OneD_> self;
> typedef std::vector<OneD_> rep_type;
> typedef refcnt_ptr< rep_type > rep_ptr;
> typedef typename OneD_::reference OneD_reference;
> typedef typename OneD_::const_reference OneD_const_reference;
> typedef typename OneD_::value_type T;
>public:
>
>
>
>
>
>
> template <class SubMatrix>
> struct partitioned {
> typedef array2D<OneD_> type;
> typedef gen_array2D<OneD_> generator;
> };
>
>
>
>
>
>
>
> typedef array2D<OneD_> transpose_type;
> typedef array2D<OneD_> submatrix_type;
> typedef array2D<OneD_> banded_view_type;
>
>
> enum { M = 0, N = 0 };
>
> typedef OneD_ OneD;
> typedef OneD& OneDRef;
> typedef const OneD& ConstOneDRef;
>
> typedef internal_tag storage_loc;
>
> typedef typename OneD::sparsity sparsity;
>
> typedef not_strideable strideability;
>
>
> typedef typename rep_type::value_type value_type;
>
> typedef typename rep_type::reference reference;
>
> typedef typename rep_type::const_reference const_reference;
>
> typedef typename rep_type::size_type size_type;
>
>
> typedef dense_iterator<typename rep_type::iterator> iterator;
>
> typedef dense_iterator<typename rep_type::const_iterator> const_iterator;
>
>
>
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
> typedef dimension<size_type> dim_type;
>
> typedef dimension<int> band_type;
>
>protected:
> inline void resize_oned(sparse_tag) {
> for (iterator i = this->begin(); i != this->end(); ++i)
> *i = OneD();
> }
>
> inline void resize_oned(dense_tag) {
> for (iterator i = this->begin(); i != this->end(); ++i)
> *i = OneD(dim.second());
>
>
>
> }
>
> inline void resize_banded(band_type , sparse_tag) {
> for (iterator i = this->begin(); i != this->end(); ++i)
> *i = OneD();
> }
> inline void resize_banded(band_type bw, dense_tag) {
> for (iterator i = this->begin(); i != this->end(); ++i) {
> band_type sf = calc_start_fini(i.index(), dim.second(), bw);
> *i = OneD(sf.second() - sf.first());
> }
>
>
>
>
>
> }
> inline void resize_banded(band_type bw) {
> resize_banded(bw, sparsity());
> }
>
>public:
>
>
>
>
> inline array2D()
> : dim(0,0), rep(0), start_index(0) { }
>
>
> inline array2D(dim_type d, size_type start_index = 0)
> : dim(d), rep(new rep_type(d.first())),
> start_index(start_index) {
> resize_oned(sparsity());
> }
>
>
> inline array2D(dim_type d, band_type band, size_type start_index = 0)
> : dim(d), rep(new rep_type(d.first())),
> start_index(start_index) {
> resize_banded(band);
> }
>
>
> template <class TwoD>
> inline array2D(const TwoD& x, band_type, banded_tag)
> : dim(x.dim), rep(x.rep), start_index(x.start_index) { }
>
>
> template <class MatrixStream, class Orien>
> inline array2D(MatrixStream& s, Orien)
> : dim(Orien::map(dim_type(s.nrows(),s.ncols()))),
> rep(new rep_type(Orien::map(dim_type(s.nrows(),s.ncols())).first())),
> start_index(0)
> {
> resize_oned(sparsity());
> }
>
>
> template <class MatrixStream, class Orien>
> inline array2D(MatrixStream& s, Orien, band_type bw)
> : dim(Orien::map(dim_type(s.nrows(),s.ncols()))),
> rep(new rep_type(Orien::map(dim_type(s.nrows(),s.ncols())).first())),
> start_index(0)
> {
> resize_banded(bw);
> }
>
>
> inline array2D(const self& x)
> : dim(x.dim), rep(x.rep), start_index(x.start_index) { }
>
>
>
>
>
>
>
> inline iterator begin() {
> return iterator(rep->begin(), start_index);
> }
>
> inline iterator end() {
> return iterator(rep->begin(), rep->size() + start_index);
> }
>
> inline const_iterator begin() const {
> return const_iterator(rep->begin(), start_index);
> }
>
> inline const_iterator end() const {
> return const_iterator(rep->begin(),
> rep->size() + start_index);
> }
>
>
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
>
>
> inline OneD_reference operator () (size_type i, size_type j) {
> return (*rep)[i][j];
> }
>
> inline OneD_const_reference operator () (size_type i, size_type j) const {
> return (*rep)[i][j];
> }
>
>
>
>
>
> inline OneDRef operator [](size_type i) {
> return (*rep)[i];
> }
>
> inline ConstOneDRef operator [](size_type i) const {
> return (*rep)[i];
> }
>
>
>
>
> inline size_type major() const { return dim.first(); }
>
> inline size_type minor() const { return dim.second(); }
>
> inline size_type nnz() const {
> size_type nz = 0;
> for (size_type i = 0; i < rep->size(); ++i) {
> nz += (*rep)[i].nnz();
> }
> return nz;
> }
>
> inline size_type capacity() const {
> size_type nz = 0;
> for (size_type i = 0; i < rep->size(); ++i) {
> nz += (*rep)[i].capacity();
> }
> return nz;
> }
>
> inline void print() const {
> for (typename rep_type::const_iterator i = rep->begin();
> i != rep->end(); ++i)
> (*i).print();
> }
>
> inline size_type first_index() const { return start_index; }
>
>
> template <class Matrix>
> inline void fast_copy(const Matrix& x) {
> typename Matrix::const_iterator xi = x.begin();
> for (iterator i = begin(); i != end(); ++i, ++xi) {
> typename Matrix::OneD::IndexArrayRef ind = (*xi).nz_struct();
> *i = OneD(ind.begin(), ind.end(), (*xi).size());
> copy(*xi, *i);
> }
> }
>
>
>
> void resize(size_type m, size_type n) {
> rep_ptr newrep = new rep_type(m);
> { for (typename rep_type::iterator i = newrep->begin();
> i != newrep->end(); ++i)
> *i = OneD(n);
> }
> size_type M = std::min(m,dim.first());
> size_type N = std::min(n,dim.second());
> size_type i, j;
> for (i = 0; i < M; ++i)
> for (j = 0; j < N; ++j)
> (*newrep)[i][j] = (*rep)[i][j];
>
> for (; i < m; ++i)
> for (; j < n; ++j)
> (*newrep)[i][j] = T();
>
> rep = newrep;
> dim = dim_type(m, n);
> }
>
>protected:
> dim_type dim;
> rep_ptr rep;
> size_type start_index;
>};
>
>
>
>template <class T>
>struct gen_array2D {
> typedef gen_array2D<T> submatrix_type;
>
>
>
>
> typedef gen_array2D<T> transpose_type;
> typedef gen_array2D<T> banded_view_type;
>
> typedef array2D<T> type;
>};
>
>}
># 40 "/usr/local/include/mtl/matrix.h" 2 3
># 1 "/usr/local/include/mtl/compressed2D.h" 1 3
># 17 "/usr/local/include/mtl/compressed2D.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 18 "/usr/local/include/mtl/compressed2D.h" 2 3
># 31 "/usr/local/include/mtl/compressed2D.h" 3
>extern "C" void foobar(int);
>
>namespace mtl {
>
>using std::less;
>using std::lower_bound;
>
>template <class T, class SizeType, int IndexOff, int M, int N>
>struct gen_compressed2D;
>template <class T, class SizeType, int IndexOff, int M, int N>
>struct gen_ext_comp2D;
># 72 "/usr/local/include/mtl/compressed2D.h" 3
>template <class ValsType, class ValPtr, class IndType, class IndPtr, int IND_OFFSET>
>class generic_comp2D {
>public:
> typedef generic_comp2D self;
> typedef ValsType values_t;
> typedef typename ValsType::value_type TT;
> typedef typename values_t::iterator value_iterator;
> typedef typename values_t::const_iterator const_value_iterator;
> typedef IndType indices_t;
> typedef typename indices_t::iterator index_iterator;
> typedef typename indices_t::const_iterator const_index_iterator;
> typedef IndType starts_t;
> typedef typename starts_t::iterator starts_iterator;
> typedef typename starts_t::const_iterator const_starts_iterator;
>
> typedef typename IndType::value_type size_type;
>
> typedef dimension<size_type> dim_type;
>
>
> typedef internal_tag storage_loc;
> enum { M = 0, N = 0 };
>
>
> class vec_ref {
> public:
> enum { N = 0 };
> typedef TT value_type;
> typedef TT* pointer;
> typedef typename IndType::value_type size_type;
> typedef typename IndType::difference_type difference_type;
> typedef elt_ref<vec_ref> reference;
> typedef const_elt_ref<vec_ref> const_reference;
> typedef sparse_tag sparsity;
> typedef oned_tag dimension;
> typedef compressed_iter<0,values_t, indices_t, IND_OFFSET> iterator;
> typedef compressed_iter<1,values_t, indices_t, IND_OFFSET> const_iterator;
>
> typedef reverse_iter< iterator > reverse_iterator;
> typedef reverse_iter< const_iterator > const_reverse_iterator;
>
> typedef light1D<size_type,0,IND_OFFSET> IndexArrayRef;
> typedef light1D<size_type,0,IND_OFFSET> IndexArray;
> typedef vec_ref subrange_type;
>
> inline vec_ref(ValPtr val, IndPtr ind, IndPtr s, size_type major_)
> : values(val), indices(ind), starts(s), major(major_) {
> }
> inline vec_ref(const vec_ref& x)
> : values(x.values), indices(x.indices), starts(x.starts),
> major(x.major) { }
>
> inline iterator begin() {
> return iterator(values->begin(), indices->begin(),
> (*starts)[major] + IND_OFFSET);
> }
> inline iterator end() {
> return iterator(values->begin(), indices->begin(),
> (*starts)[major+1] + IND_OFFSET);
> }
> inline const_iterator begin() const {
> return const_iterator(((const values_t*)values)->begin(),
> ((const indices_t*)indices)->begin(),
> (*starts)[major] + IND_OFFSET);
> }
> inline const_iterator end() const {
> return const_iterator(((const values_t*)values)->begin(),
> ((const indices_t*)indices)->begin(),
> (*starts)[major+1] + IND_OFFSET);
> }
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
> inline reference operator[](size_type i) {
> return reference(*this, i);
> }
>
> inline const_reference operator[](size_type i) const {
> return const_reference(*this, i);
> }
>
>
> value_type& get_ref(size_type i) {
> iterator iter = find(i);
>
>
>
>
>
>
>
> ((iter.index() == i) ? static_cast<void> (0) : (__assert_fail ("iter.index() == i", "/usr/local/include/mtl/compressed2D.h", 174, __PRETTY_FUNCTION__), static_cast<void> (0)));
> return *iter;
> }
>
>
> inline size_type size() const { return nnz(); }
>
> inline size_type nnz() const {
> return (*starts)[major+1] - (*starts)[major];
> }
>
> inline IndexArrayRef nz_struct() const {
> size_type first = (*starts)[major] + IND_OFFSET;
> size_type last = (*starts)[major + 1] + IND_OFFSET;
> return IndexArrayRef(&(*indices)[0] + first, last - first);
> }
>
> inline iterator find(size_type i) {
> difference_type first = (*starts)[major] + IND_OFFSET;
> difference_type last = (*starts)[major + 1] + IND_OFFSET;
> index_iterator indices_begin = indices->begin();
> index_iterator iter = lower_bound(indices_begin + first,
> indices_begin + last,
> size_type(i - IND_OFFSET));
> size_type n = iter - indices_begin;
> return iterator(values->begin(), indices_begin, n);
> }
>
> inline const_iterator find(size_type i) const {
> difference_type first = (*starts)[major] + IND_OFFSET;
> difference_type last = (*starts)[major + 1] + IND_OFFSET;
> const_index_iterator indices_begin =
> ((const indices_t*)indices)->begin();
> const_index_iterator iter = lower_bound(indices_begin + first,
> indices_begin + last,
> i - IND_OFFSET);
> size_type n = iter - indices_begin;
> return const_iterator(((const values_t*)values)->begin(),
> indices_begin, n);
> }
>
> inline iterator insert(iterator iter, size_type i, TT v) {
> index_iterator ind = indices->insert(iter.index_iter(),
> size_type(i - IND_OFFSET));
> values->insert(iter.value_iter(), v);
> size_type n = ind - indices->begin();
> increment_starts(major + 1);
> return iterator(values->begin(), indices->begin(), n);
> }
>
> inline void increment_starts(size_type i) {
> while (i < size_type(starts->size()))
> ++(*starts)[i++];
> }
>
> inline void resize(size_type) { }
>
> private:
>
> ValPtr values;
> IndPtr indices;
> IndPtr starts;
> size_type major;
> };
>
>public:
>
>
> typedef vec_ref value_type;
>
> typedef vec_ref reference;
>
> typedef const vec_ref const_reference;
>
>
> typedef vec_ref MajorVector;
> typedef vec_ref MajorVectorRef;
> typedef const vec_ref ConstMajorVectorRef;
>public:
>
> typedef sparse_tag sparsity;
>
>
> typedef not_strideable strideability;
>
>
> typedef generic_comp2D<ValsType,ValPtr,IndType,IndPtr,IND_OFFSET> transpose_type;
> typedef generic_comp2D<ValsType,ValPtr,IndType,IndPtr,IND_OFFSET> submatrix_type;
> typedef generic_comp2D<ValsType,ValPtr,IndType,IndPtr,IND_OFFSET> banded_view_type;
>
>
>
>
> template <int isConst>
> class _iterator {
> typedef _iterator self;
> public:
> typedef typename IF<isConst, const_value_iterator, value_iterator>::RET
> value_iter;
>
> typedef typename std::iterator_traits<value_iter>::iterator_category
> iterator_category;
>
>
>
>
>
> typedef typename std::iterator_traits<value_iter>::difference_type
> difference_type;
>
>
> typedef MajorVectorRef value_type;
>
> typedef typename IF<isConst, const MajorVectorRef, MajorVectorRef>::RET reference;
> typedef typename IF<isConst, const MajorVectorRef*, MajorVectorRef*>::RET pointer;
>
> typedef typename IF<isConst, const ValPtr, ValPtr>::RET myValPtr;
> typedef typename IF<isConst, const IndPtr, IndPtr>::RET myIndPtr;
>
> inline _iterator() : pos(0) { }
> inline _iterator(myValPtr val, myIndPtr ind, myIndPtr s, size_type p)
> : values(val), indices(ind), starts(s), pos(p) { }
> inline _iterator(const self& x)
> : values(x.values), indices(x.indices), starts(x.starts), pos(x.pos) { }
>
> inline size_type index() const { return pos; }
>
> inline reference operator*() const {
> return reference(values, indices, starts, pos);
> }
> inline self& operator++() { ++pos; return *this; }
> inline self& operator--() { --pos; return *this; }
> inline self& operator+=(size_type n) { pos += n; return *this; }
> inline self& operator-=(size_type n) { pos -= n; return *this; }
> inline difference_type operator-(const self& x) const {
> return pos - x.pos; }
> inline bool operator<(const self& x) const { return pos < x.pos; }
> inline bool operator!=(const self& x) const { return pos != x.pos; }
> inline bool operator==(const self& x) const { return pos == x.pos; }
> private:
> ValPtr values;
> IndPtr indices;
> IndPtr starts;
> size_type pos;
> };
>
> typedef _iterator<0> iterator;
> typedef _iterator<1> const_iterator;
># 430 "/usr/local/include/mtl/compressed2D.h" 3
> typedef reverse_iter< iterator > reverse_iterator;
>
> typedef reverse_iter< const_iterator > const_reverse_iterator;
>
>
>
>
> inline generic_comp2D() : dim(0,0), values(0), indices(0), starts(0) { }
>
>
> inline generic_comp2D(dim_type d, ValPtr v, IndPtr ind, IndPtr s)
> : dim(d), values(v), indices(ind), starts(s) { }
>
>
> inline generic_comp2D(const self& x)
> : dim(x.dim), values(x.values), starts(x.starts), indices(x.indices) { }
>
> inline self& operator=(const self& x) {
> dim = x.dim; values = x.values; starts = x.starts; indices = x.indices;
> return *this;
> }
>
>
>
>
>
> inline iterator begin() {
> return iterator(values, indices, starts, 0);
> }
>
> inline iterator end() {
> return iterator(values, indices, starts, dim.first());
> }
>
>
> inline const_iterator begin() const {
> return const_iterator(values, indices, starts, 0);
> }
>
> const_iterator end() const {
> return const_iterator(values, indices, starts, dim.first());
> }
>
>
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
>
> inline typename reference::reference
> operator()(size_type i, size_type j) {
> return MajorVectorRef(values, indices, starts, i)[j];
> }
>
> inline typename const_reference:: const_reference
> operator()(size_type i, size_type j) const {
> return ConstMajorVectorRef(values, indices, starts, i)[j];
> }
>
>
>
>
>
> inline size_type major() const { return dim.first(); }
>
> inline size_type minor() const { return dim.second(); }
>
> inline size_type nnz() const { return values->size(); }
>
>
>
>
> inline value_type operator[](size_type i) const {
> return MajorVector(values, indices, starts, i);
> }
>
>
>
>
> inline TT* get_val() { return values->data(); }
>
> inline const TT* get_val() const { return values->data(); }
>
>
> inline size_type* get_ind() { return indices->data(); }
>
> inline const size_type* get_ind() const { return indices->data(); }
>
>
> inline size_type* get_ptr() { return starts->data(); }
>
> inline const size_type* get_ptr() const { return starts->data(); }
>
>
> template <class SparseMat>
> void fast_copy(const SparseMat& x, sparse_tag) {
> size_type nnz = x.nnz();
> typename SparseMat::const_iterator i;
> typename SparseMat::OneD::const_iterator j, jend;
>
> values->resize(nnz);
> indices->resize(nnz);
> starts->resize(x.major() + 1);
>
> size_type curr = 0;
>
> for (i = x.begin(); i != x.end(); ++i) {
> (*starts)[i.index()] = curr - IND_OFFSET;
> jend = (*i).end();
> for (j = (*i).begin(); j != jend; ++j) {
> (*values)[curr] = *j;
> (*indices)[curr++] = j.index() - IND_OFFSET;
> }
> }
> (*starts)[i.index()] = curr - IND_OFFSET;
> }
>
> template <class DenseMat>
> void fast_copy(const DenseMat x, dense_tag) {
> typename DenseMat::const_iterator i;
> typename DenseMat::OneD::const_iterator j;
>
> size_type nnz = 0;
>
>
> for (i = x.begin(); i != x.end(); ++i)
> for (j = (*i).begin(); j != (*i).end(); ++j)
> if (*j != TT(0))
> ++nnz;
>
> values->resize(nnz);
> indices->resize(nnz);
> starts->resize(x.major() + 1);
>
> size_type curr = 0;
>
> for (i = x.begin(); i != x.end(); ++i) {
> (*starts)[i.index()] = curr - IND_OFFSET;
> for (j = (*i).begin(); j != (*i).end(); ++j) {
> if (*j != TT(0)) {
> (*values)[curr] = *j;
> (*indices)[curr++] = j.index() - IND_OFFSET;
> }
> }
> }
> (*starts)[i.index()] = curr - IND_OFFSET;
> }
> template <class TwoD__>
> void fast_copy(const TwoD__& x) {
> typedef typename TwoD__::sparsity Sparsity;
> fast_copy(x, Sparsity());
> }
>
> void print() const {
> std::cout << "values ";
> print_vector(*values);
> std::cout << "indices ";
> print_vector(*indices);
> std::cout << "starts ";
> print_vector(*starts);
> }
>
>protected:
> dim_type dim;
> ValPtr values;
> IndPtr indices;
> IndPtr starts;
>};
># 628 "/usr/local/include/mtl/compressed2D.h" 3
>template <class T, class SizeType, int IND_OFFSET>
>class compressed2D : public generic_comp2D< dense1D<T>, dense1D<T>*,
> dense1D<SizeType>,
> dense1D<SizeType>* , IND_OFFSET>
>{
>
> typedef generic_comp2D< dense1D<T>, dense1D<T>*,
> dense1D<SizeType>,
> dense1D<SizeType>* , IND_OFFSET> Base;
>
> typedef compressed2D<T, SizeType,IND_OFFSET> self;
>public:
> typedef typename Base::dim_type dim_type;
>
>
> typedef SizeType size_type;
>
> typedef dimension<int> band_type;
>
>
> inline compressed2D() : Base(dim_type(0,0), &vals, &inds, &ptrs) { }
>
>
> inline compressed2D(dim_type d)
> : Base(d, &vals, &inds, &ptrs),
> ptrs(d.first() + 1, -IND_OFFSET)
> {
> vals.reserve(Base::dim.first() * 5);
> inds.reserve(Base::dim.first() * 5);
> }
>
> inline compressed2D(dim_type d, size_type nnz)
> : Base(d, &vals, &inds, &ptrs),
> ptrs(d.first() + 1, -IND_OFFSET)
> {
> vals.reserve(nnz);
> inds.reserve(nnz);
> }
>
>
> inline compressed2D(dim_type d, band_type)
> : Base(d, &vals, &inds, &ptrs),
> ptrs(d.first() + 1, -IND_OFFSET)
> {
> vals.reserve(Base::dim.first() * 5);
> inds.reserve(Base::dim.first() * 5);
> }
>
>
> inline compressed2D(const self& x)
> : Base(x.dim, &vals, &inds, &ptrs),
> vals(x.vals), ptrs(x.ptrs), inds(x.inds)
> { }
>
>
> inline compressed2D(const self& x, band_type, banded_tag)
> : Base(x.dim, &vals, &inds, &ptrs),
> vals(x.vals), ptrs(x.ptrs), inds(x.inds)
> { }
>
> inline self& operator=(const self& x) {
> vals = x.vals; ptrs = x.ptrs; inds = x.inds;
>
> Base::dim = x.dim;
> Base::values = &vals; Base::indices = &inds; Base::starts = &ptrs;
> return *this;
> }
>
>
> template <class MatrixStream, class Orien>
> inline compressed2D(MatrixStream& s, Orien)
> : Base(Orien::map(dim_type(s.nrows(),s.ncols())), &vals, &inds, &ptrs),
> ptrs(1 + Orien::map(dim_type(s.nrows(),s.ncols())).first(), -IND_OFFSET)
> {
> vals.reserve(s.nnz());
> inds.reserve(s.nnz());
> }
>
>
> template <class MatrixStream, class Orien>
> inline compressed2D(MatrixStream& s, Orien, band_type)
> : Base(Orien::map(dim_type(s.nrows(),s.ncols())), &vals, &inds, &ptrs),
> ptrs(1 + Orien::map(dim_type(s.nrows(),s.ncols())).first(), -IND_OFFSET)
> {
> vals.reserve(s.nnz());
> inds.reserve(s.nnz());
> }
># 723 "/usr/local/include/mtl/compressed2D.h" 3
> inline size_type capacity() const { return inds.capacity(); }
>
>protected:
> dense1D<T> vals;
> dense1D<size_type> ptrs;
> dense1D<size_type> inds;
>};
># 744 "/usr/local/include/mtl/compressed2D.h" 3
>template <class T, class SizeType, int IND_OFFSET>
>class ext_comp2D : public generic_comp2D< external_vec<T,0,SizeType>,
> external_vec<T,0,SizeType>*,
> external_vec<SizeType,0,SizeType>,
> external_vec<SizeType,0,SizeType>*,
> IND_OFFSET >
>{
>
> typedef ext_comp2D<T, SizeType,IND_OFFSET> self;
>
> typedef generic_comp2D< external_vec<T,0,SizeType>,
> external_vec<T,0,SizeType>*,
> external_vec<SizeType,0,SizeType>,
> external_vec<SizeType,0,SizeType>*,
> IND_OFFSET > Base;
>public:
> typedef typename Base::dim_type dim_type;
>
> external_vec<T,0,SizeType> vals;
> typedef SizeType size_type;
> external_vec<size_type,0,SizeType> inds;
> external_vec<size_type,0,SizeType> ptrs;
>
> typedef typename external_vec<size_type,0,SizeType>::size_type rep_size_t;
>
> inline ext_comp2D() { }
>
> inline ext_comp2D(dim_type d, size_type nz,
> T* val, size_type* ptr, size_type* ind)
> : Base(d, &vals, &inds, &ptrs),
> vals(val, nz),
> inds(ind, nz),
> ptrs(ptr, rep_size_t(d.first() + 1))
> { }
>
>
> inline ext_comp2D(const self& x)
> : Base(dim_type(x.major(), x.minor()), &vals, &inds, &ptrs),
> vals(x.vals),
> inds(x.inds),
> ptrs(x.ptrs)
> { }
>
> inline self& operator=(const self& x) {
> vals = x.vals; inds = x.inds; ptrs = x.ptrs;
>
> Base::dim = x.dim;
> Base::values = &vals; Base::indices = &inds; Base::starts = &ptrs;
> return *this;
> }
>
>
> typedef dimension<int> band_type;
> inline ext_comp2D(const self& x, band_type, banded_tag)
> : Base(x.dim, &vals, &inds, &ptrs),
> vals(x.vals),
> inds(x.inds),
> ptrs(x.ptrs)
> { }
># 811 "/usr/local/include/mtl/compressed2D.h" 3
>};
>
>
>
>template <class T, class SizeType, int INDEX, int M, int N>
>struct gen_compressed2D {
> typedef gen_compressed2D<T,SizeType,INDEX,M,N> submatrix_type;
> typedef gen_dense2D<T,gen_rect_offset<M,N>,N,M> transpose_type;
> typedef gen_dense2D<T,gen_rect_offset<M,N>,M,N> banded_view_type;
>
> typedef compressed2D<T, SizeType,INDEX> type;
>};
>
>
>
>
>
>template <class T, class SizeType, int INDEX, int M, int N>
>struct gen_ext_comp2D {
> typedef gen_ext_comp2D<T, SizeType,INDEX,M,N> submatrix_type;
> typedef gen_dense2D<T,gen_rect_offset<N,M>,N,M> transpose_type;
> typedef gen_dense2D<T,gen_rect_offset<M,N>,M,N> banded_view_type;
> typedef ext_comp2D<T, SizeType,INDEX> type;
>};
>
>
>
>
>}
># 41 "/usr/local/include/mtl/matrix.h" 2 3
># 1 "/usr/local/include/mtl/envelope2D.h" 1 3
># 24 "/usr/local/include/mtl/envelope2D.h" 3
>namespace mtl {
>
>
>template <class T, int M, int N>
>struct gen_envelope2D;
># 51 "/usr/local/include/mtl/envelope2D.h" 3
>template <class T>
>class envelope2D {
>public:
>
>
>
>
> typedef dense1D<T> values_t;
> typedef typename values_t::iterator values_iterator;
> typedef typename values_t::const_iterator const_values_iterator;
>
> typedef typename values_t::size_type size_type;
> typedef typename values_t::difference_type difference_type;
> typedef dense1D<size_type> ptr_t;
>
>
> typedef dimension<size_type> dim_type;
> enum { M = 0, N = 0 };
>
> typedef internal_tag storage_loc;
>
> typedef twod_tag dimension;
>
> class vec_ref {
> public:
> enum { N = 0 };
>
> typedef dense_iterator<values_iterator> iterator;
> typedef dense_iterator<const_values_iterator> const_iterator;
>
>
>
>
> typedef reverse_iter<iterator> reverse_iterator;
> typedef reverse_iter<const_iterator> const_reverse_iterator;
> typedef typename values_t::value_type value_type;
> typedef typename values_t::pointer pointer;
> typedef elt_ref<vec_ref> reference;
> typedef const_elt_ref<vec_ref> const_reference;
> typedef typename values_t::size_type size_type;
> typedef typename values_t::difference_type difference_type;
> typedef scaled1D<vec_ref> scaled_type;
> typedef dense_tag sparsity;
> typedef oned_tag dimension;
>
>
> typedef light1D<T> subrange_type;
> typedef dense1D<size_type> IndexArrayRef;
>
> inline vec_ref(size_type major, values_t* v, ptr_t* p)
> : i(major), val_p(v), ptr_p(p) { }
>
> inline vec_ref(const vec_ref& x)
> : i(x.i), val_p(x.val_p), ptr_p(x.ptr_p) { }
>
> inline iterator begin() {
> return iterator(__begin(), 0, start_index());
> }
> inline iterator end() {
> return iterator(__begin(), size(), finish_index());
> }
> inline const_iterator begin() const {
> return const_iterator(__begin(), 0, start_index());
> }
> inline const_iterator end() const {
> return const_iterator(__begin(), size(), finish_index());
> }
> inline reverse_iterator rbegin() { return reverse_iterator(end()); }
> inline reverse_iterator rend() { return reverse_iterator(begin()); }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
> inline reference operator[](size_type ii) {
> return reference(*this, ii);
> }
> inline const_reference operator[](size_type ii) const {
> return const_reference(*this, ii);
> }
>
> inline size_type size() const {
> if (i > 0)
> return (*ptr_p)[i] - (*ptr_p)[i-1];
> else
> return (*ptr_p)[i] + 1;
> }
> inline size_type nnz() const { return size(); }
>
>
>
>
>
>
>
> inline iterator find(size_type j) {
> ;
> if (j >= start_index()) {
> return begin() + j + size() - i - 1;
> } else {
> return end();
> }
> }
> inline const_iterator find(size_type j) const {
> ;
> if (j >= start_index())
> return const_iterator(__begin(), j + size() - i - 1);
> else
> return end();
> }
>
>
>
>
> inline iterator insert(iterator , size_type j, T v) {
> size_type increase = i + 1 - j - size();
> val_p->insert(__begin(), increase, T(0));
> increment_ptr(increase);
> *begin() = v;
> return begin();
> }
>
> protected:
> inline size_type start_index() const { return i - size() + 1; }
> inline size_type finish_index() const { return i; }
>
> inline values_iterator __begin() {
> if (i > 0)
> return val_p->begin() + (*ptr_p)[i-1] + 1;
> return val_p->begin();
> }
> inline const_values_iterator __begin() const {
> if (i > 0)
> return ((const values_t*)val_p)->begin() + (*ptr_p)[i-1] + 1;
> else
> return ((const values_t*)val_p)->begin();
> }
> inline void increment_ptr(size_type amount) {
> for (size_type ii = i; ii < ptr_p->size(); ++ii)
> (*ptr_p)[ii] += amount;
> }
>
> size_type i;
> values_t* val_p;
> ptr_t* ptr_p;
> };
>
>
> typedef vec_ref value_type;
>
> typedef vec_ref reference;
>
> typedef const vec_ref const_reference;
>
>
> typedef sparse_tag sparsity;
>
> typedef not_strideable strideability;
> typedef envelope2D<int> transpose_type;
>
>
>
>
> class iterator {
> typedef iterator self;
> public:
> typedef typename std::iterator_traits<values_iterator>::iterator_category iterator_category;
> typedef typename std::iterator_traits<values_iterator>::difference_type difference_type;
> typedef vec_ref value_type;
> typedef vec_ref reference;
> typedef vec_ref* pointer;
> inline iterator() : i(0), val_p(0), ptr_p(0) { }
> inline iterator(values_t* v, ptr_t* p, size_type ii)
> : val_p(v), ptr_p(p), i(ii) { }
> inline vec_ref operator*() const { return vec_ref(i, val_p, ptr_p); }
> inline self& operator++() { ++i; return *this; }
> inline self& operator+=(size_type n) { i += n; return *this; }
> inline self operator++(int) { self t = *this; ++(*this); return t; }
> inline self& operator--() { --i; return *this; }
> inline self& operator-=(size_type n) { i -= n; return *this; }
> inline self operator--(int) { self t = *this; --(*this); return t; }
> inline bool operator!=(const self& x) const { return i != x.i; }
> inline bool operator==(const self& x) const { return i == x.i; }
> inline bool operator<(const self& x) const { return i < x.i; }
> inline size_type index() const { return i; }
> protected:
> size_type i;
> values_t* val_p;
> ptr_t* ptr_p;
> };
>
>
>
>
> class const_iterator : public iterator {
> typedef const_iterator self;
> public:
> typedef typename std::iterator_traits<values_iterator>::iterator_category iterator_category;
> typedef typename std::iterator_traits<values_iterator>::difference_type difference_type;
> typedef vec_ref value_type;
> typedef vec_ref reference;
> typedef vec_ref* pointer;
> inline const_iterator() : i(0), val_p(0), ptr_p(0) { }
> inline const_iterator(values_t* v, ptr_t* p, size_type ii)
> : val_p(v), ptr_p(p), i(ii) { }
> inline const vec_ref operator*() const { return vec_ref(i, val_p, ptr_p); }
> inline self& operator++() { ++i; return *this; }
> inline self& operator+=(size_type n) { i += n; return *this; }
> inline self operator++(int) { self t = *this; ++(*this); return t; }
> inline self& operator--() { --i; return *this; }
> inline self& operator-=(size_type n) { i -= n; return *this; }
> inline self operator--(int) { self t = *this; --(*this); return t; }
> inline bool operator!=(const self& x) const { return i != x.i; }
> inline bool operator==(const self& x) const { return i == x.i; }
> inline bool operator<(const self& x) const { return i < x.i; }
> inline size_type index() const { return i; }
> protected:
> size_type i;
> values_t* val_p;
> ptr_t* ptr_p;
> };
>
>
> typedef reverse_iter<iterator> reverse_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
> inline envelope2D() : dim(0,0) { }
>
> inline envelope2D(dim_type d)
> : dim(d), val(1, T(0)), ptr(d.first(), size_type(0))
> {
> val.reserve(dim.first() * 5);
> }
>
> inline envelope2D(dim_type d, dim_type)
> : dim(d), val(1, T(0)), ptr(d.first(), size_type(0))
> {
> val.reserve(dim.first() * 5);
> }
>
> inline envelope2D(const envelope2D& x)
> : dim(x.dim), val(x.val), ptr(x.ptr) { }
>
>
>
>
> template <class Array> inline
> void initialize_nzstruct(const Array& a, size_type nnz) {
> val.resize(nnz, T(0));
> for (int x = 1; x < dim.first(); ++x)
> ptr[x] = ptr[x-1] + a[x-1];
> }
>
>
> inline iterator begin() { return iterator(&val, &ptr, 0); }
>
>
> inline iterator end() { return iterator(&val, &ptr, dim.first()); }
>
>
> inline const_iterator begin() const {
> return const_iterator((values_t*)&val, (ptr_t*)&ptr, 0);
> }
>
> inline const_iterator end() const{
> return const_iterator((values_t*)&val, (ptr_t*)&ptr, dim.first());
> }
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
> inline size_type major() const { return dim.first(); }
>
> inline size_type minor() const { return dim.second(); }
>
> inline size_type nnz() const { return val.size(); }
>
>
> inline typename vec_ref::reference
> operator()(size_type i, size_type j) {
> return reference(i, &val, &ptr)[j];
> }
>
> inline const typename vec_ref::reference
> operator()(size_type i, size_type j) const {
> return const_reference(i, (values_t*)&val, (ptr_t*)&ptr)[j];
> }
>
>
> inline reference operator[](size_type i) {
> return reference(i, &val, &ptr);
> }
>
> inline const_reference operator[](size_type i) const {
> return const_reference(i, (values_t*)&val, (ptr_t*)&ptr);
> }
>
> inline void print() const {
> print_vector(val);
> print_vector(ptr);
> }
># 381 "/usr/local/include/mtl/envelope2D.h" 3
>protected:
> dim_type dim;
> values_t val;
> ptr_t ptr;
>};
>
>
>
>
>template <class T, int M, int N>
>struct gen_envelope2D {
> typedef gen_envelope2D<T,M,N> submatrix_type;
> typedef gen_envelope2D<int,N,M> transpose_type;
> typedef gen_envelope2D<int,M,N> banded_view_type;
> typedef envelope2D<T> type;
>};
>
>}
># 42 "/usr/local/include/mtl/matrix.h" 2 3
>
>
># 1 "/usr/local/include/mtl/sparse1D.h" 1 3
># 22 "/usr/local/include/mtl/sparse1D.h" 3
># 1 "/usr/local/include/mtl/sparse_iterator.h" 1 3
># 17 "/usr/local/include/mtl/sparse_iterator.h" 3
># 1 "/usr/local/include/mtl/mtl_iterator.h" 1 3
># 18 "/usr/local/include/mtl/sparse_iterator.h" 2 3
>
>namespace mtl {
>
>using std::random_access_iterator_tag;
>using std::output_iterator_tag;
>using std::advance;
>using std::distance;
>
>
> template <class Cat> struct choose {
> template <class Iterator, class self>
> static inline self add(Iterator i, int, int n, self*) {
> std::advance(i, n);
> return self(i);
> }
> template <class Iterator, class self>
> static inline self sub(Iterator i, int n, self*) {
> std::advance(i, -n);
> return self(i);
> }
> template <class self>
> static inline int diff(const self& x, const self& y) {
> return distance(x.iter, y.iter);
> }
> template <class Iterator>
> static inline void init(Iterator& iter, int& pos,
> const Iterator& ,
> const Iterator& finish) {
> iter = finish;
> pos = 0;
> }
> template <class self>
> static inline bool lessthan(const self& x, const self& y) {
> return x.pos < y.pos; }
>
> template <class self>
> static inline bool notequal(const self& x, const self& y) {
> return x.pos != y.pos; }
>
> template <class Iterator>
> static inline Iterator convert(const Iterator& iter, int) {
> return iter; }
>
> template <class Iterator>
> static inline int index(Iterator iter, int) {
> return (*iter).index; }
>
> template <class Iterator>
> static inline void inc(Iterator& iter, int&) { ++iter; }
>
> template <class Iterator>
> static inline void dec(Iterator& iter, int&) { --iter; }
>
> template <class Iterator, class Val>
> static inline Val&
> deref(Iterator iter, int, Val*) {
> return (*iter).value; }
>
> template <class Iterator>
> inline void add_assign(Iterator& iter, int&, int n) {
> advance(iter,n); }
>
> template <class Iterator>
> inline void sub_assign(Iterator& iter, int&, int n) {
> advance(iter,n); }
>
> };
>
> template <> struct choose<random_access_iterator_tag> {
>
> template <class Iterator, class self>
> static inline self add(Iterator iter, int pos, int n, self*) {
> return self(iter, pos + n); }
>
> template <class Iterator, class self>
> static inline self sub(Iterator iter, int pos, int n, self*) {
> return self(iter, pos - n); }
>
> template <class self>
> static inline int diff(const self& x, const self& y) {
> return x.pos - y.pos; }
>
> template <class Iterator>
> static inline void init(Iterator& iter, int& pos,
> const Iterator& start, const Iterator& finish) {
> iter = start;
> pos = finish - start;
> }
>
> template <class self>
> static inline bool lessthan(const self& x, const self& y) {
> return x.iter < y.iter; }
>
> template <class self>
> static inline bool notequal(const self& x, const self& y) {
> return x.iter != y.iter; }
>
> template <class Iterator>
> static inline Iterator convert(const Iterator& iter, int pos) {
> return iter + pos; }
>
> template <class Iterator>
> static inline int index(Iterator iter, int pos) {
> return (*(iter + pos)).index; }
>
> template <class Iterator>
> static inline void inc(Iterator&, int& pos) { ++pos; }
>
> template <class Iterator>
> static inline void dec(Iterator&, int& pos) { --pos; }
>
> template <class Iterator, class Val>
> static inline Val&
> deref(const Iterator& iter, int pos, Val*) {
> return (*(iter + pos)).value; }
>
> template <class Iterator>
> static inline void add_assign(Iterator&, int& pos, int n) {
> pos += n; }
>
> template <class Iterator>
> static inline void sub_assign(Iterator&, int& pos, int n) {
> pos -= n; }
>
> };
>
>
>
>
>template <class Iterator, class T>
>class const_sparse_iterator;
># 161 "/usr/local/include/mtl/sparse_iterator.h" 3
>template <class Iterator, class T>
>class sparse_iterator {
> typedef sparse_iterator<Iterator,T> self;
> typedef typename std::iterator_traits<Iterator>::iterator_category cat;
>public:
> typedef cat iterator_category;
> typedef T value_type;
> typedef int difference_type;
> typedef T& reference;
> typedef T* pointer;
>
>public:
>
> inline sparse_iterator() { }
>
> inline sparse_iterator(const sparse_iterator& x)
> : iter(x.iter), pos(x.pos) { }
>
> inline sparse_iterator(const Iterator& iter_, int p = 0)
> : iter(iter_), pos(p) { }
>
> inline sparse_iterator(const Iterator& start, const Iterator& finish) {
> choose<cat>::init(iter, pos, start, finish); }
>
> inline operator Iterator() const { return choose<cat>::convert(iter, pos); }
>
> inline int index() const { return choose<cat>::index(iter, pos); }
>
> inline bool operator!=(const self& x) const {
> return choose<cat>::notequal(*this, x); }
>
> inline bool operator<(const self& x) const {
> return choose<cat>::lessthan(*this, x); }
>
> inline reference operator*() const {
> return choose<cat>::deref(iter, pos, pointer()); }
>
> inline int operator-(const self& x) const {
> return choose<cat>::diff(*this, x); }
>
> inline self& operator++() {
> choose<cat>::inc(iter, pos); return *this; }
>
> inline self operator++(int) {
> self tmp = *this; choose<cat>::inc(iter, pos); return tmp; }
>
> inline self& operator--() {
> choose<cat>::dec(iter, pos); return *this; }
>
> inline self& operator+=(int n) {
> choose<cat>::add_assign(iter, pos, n); return *this; }
>
> inline self& operator-=(int n) {
> choose<cat>::sub_assign(iter, pos, n); return *this; }
>
> inline Iterator base() const { return choose<cat>::convert(iter, pos); }
>
> inline self operator+(int n) const {
> return choose<cat>::add(iter, pos, n, this); }
> inline self operator-(int n) const {
> return choose<cat>::sub(iter, pos, n, this); }
>
>public:
> Iterator iter;
> int pos;
>};
>
>template <class Iterator, class T>
>inline bool
>operator==(const sparse_iterator<Iterator, T>& a,
> const sparse_iterator<Iterator, T>& b)
>{
> return a.base() == b.base();
>}
>
>
>
>template <class Iterator, class T>
>class const_sparse_iterator {
> typedef const_sparse_iterator<Iterator,T> self;
> typedef typename std::iterator_traits<Iterator>::iterator_category cat;
>public:
> typedef cat iterator_category;
> typedef T value_type;
> typedef int difference_type;
> typedef const T& reference;
> typedef T* pointer;
>public:
>
> inline const_sparse_iterator() { }
>
> inline const_sparse_iterator(const const_sparse_iterator& x)
> : iter(x.iter), pos(x.pos) { }
>
> inline const_sparse_iterator(const Iterator& iter_, int p = 0)
> : iter(iter_), pos(p) { }
>
> inline const_sparse_iterator(const Iterator& start, const Iterator& finish) {
> choose<cat>::init(iter, pos, start, finish); }
>
> template <class Iter>
> inline const_sparse_iterator(const sparse_iterator<Iter,T>& si)
> : iter(si.iter), pos(si.pos) { }
>
> inline operator Iterator() const { return choose<cat>::convert(iter, pos); }
>
> inline int index() const { return choose<cat>::index(iter, pos); }
>
> inline bool operator!=(const self& x) const {
> return choose<cat>::notequal(*this, x); }
>
> inline bool operator<(const self& x) const {
> return choose<cat>::lessthan(*this, x); }
>
> inline reference operator*() const {
> return choose<cat>::deref(iter, pos, pointer()); }
>
> inline int operator-(const self& x) const {
> return choose<cat>::diff(*this, x); }
>
> inline self& operator++() {
> choose<cat>::inc(iter, pos); return *this; }
>
> inline self operator++(int) {
> self tmp = *this; choose<cat>::inc(iter, pos); return tmp; }
>
> inline self& operator--() {
> choose<cat>::dec(iter, pos); return *this; }
>
> inline self& operator+=(int n) {
> choose<cat>::add_assign(iter, pos, n); return *this; }
>
> inline self& operator-=(int n) {
> choose<cat>::sub_assign(iter, pos, n); return *this; }
>
> inline Iterator base() const { return choose<cat>::convert(iter, pos); }
>
> inline self operator+(int n) const {
> return choose<cat>::add(iter, pos, n, this); }
> inline self operator-(int n) const {
> return choose<cat>::sub(iter, pos, n, this); }
>
>public:
> Iterator iter;
> int pos;
>};
>
>template <class Iterator, class T>
>inline bool
>operator==(const const_sparse_iterator<Iterator, T>& a,
> const const_sparse_iterator<Iterator, T>& b)
>{
> return a.base() == b.base();
>}
>
>
>}
># 23 "/usr/local/include/mtl/sparse1D.h" 2 3
>
>
>
>
>
>
>
>namespace mtl {
>
>using std::lower_bound;
>using std::find;
>
>
>
>
>
>template <class RepType>
>class sp1D_index_array {
> typedef sp1D_index_array<RepType> self;
>public:
> typedef int value_type;
> typedef int* pointer;
> typedef const int& reference;
> typedef const int& const_reference;
>
> typedef typename RepType::const_iterator rep_iter;
>
> class iterator {
> typedef iterator self;
> public:
> typedef const int& reference;
> inline iterator() { }
> inline iterator(rep_iter i) : iter(i) { }
> inline reference operator*() const { return iter.index(); }
> inline reference operator[](int n) const { return iter.index(); }
> inline self& operator++() { ++iter; return *this; }
> inline self operator++(int) { self t = *this; ++iter; return t; }
> inline self& operator--() { --iter; return *this; }
> inline self operator--(int) { self t = *this; --iter; return t; }
> inline bool operator!=(const self& x) { return iter != x.iter; }
> inline bool operator<(const self& x) { return iter < x.iter; }
> inline bool operator==(const self& x) { return iter == x.iter; }
> inline iterator operator+(int n) {
> return iterator(iter + n);
> }
> inline iterator operator-(int n) {
> return iterator(iter - n);
> }
> protected:
> rep_iter iter;
> };
>
> typedef iterator const_iterator;
>
> typedef reverse_iter<iterator> reverse_iterator;
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
> sp1D_index_array(rep_iter s, rep_iter f) : start(s), finish(f) { }
>
> sp1D_index_array(const self& x) : start(x.start), finish(x.finish) { }
>
> inline const_iterator begin() { return start; }
> inline const_iterator end() { return finish; }
> inline const_reverse_iterator rbegin() {
> return const_reverse_iterator(finish); }
> inline const_reverse_iterator rend() {
> return const_reverse_iterator(start); }
> inline reference operator[](int n) {
> return start[n];
> }
>
>
>
>
>
> rep_iter start;
> rep_iter finish;
>};
># 110 "/usr/local/include/mtl/sparse1D.h" 3
>template <class T, class R>
>inline typename T::iterator __sparseoned_find(T* oned, int i, R*) {
> return oned->__find_normal(i);
>}
># 138 "/usr/local/include/mtl/sparse1D.h" 3
>template <class RepType>
>class sparse1D {
> typedef sparse1D<RepType> self;
> typedef RepType rep_type;
> typedef rep_type ref_cont;
> typedef typename rep_type::iterator rep_type_iterator;
> typedef typename rep_type::const_iterator const_rep_type_iterator;
>public:
>
>
> enum { N = 0 };
>
>
> typedef sparse_tag sparsity;
>
> typedef typename RepType::value_type entry_type;
>
>
> typedef oned_tag dimension;
>
>
> typedef scaled1D< sparse1D< RepType > > scaled_type;
>
> typedef typename entry_type::value_type value_type;
>
> typedef value_type* pointer;
>
> typedef typename RepType::size_type size_type;
>
> typedef typename RepType::difference_type difference_type;
>
>
> typedef elt_ref<self> reference;
>
> typedef value_type const_reference;
>
> typedef sparse_iterator<rep_type_iterator,value_type> iterator;
>
> typedef const_sparse_iterator<const_rep_type_iterator,value_type>
> const_iterator;
>
> typedef reverse_iter<iterator> reverse_iterator;
>
> typedef reverse_iter<const_iterator> const_reverse_iterator;
>
>
> typedef sp1D_index_array<RepType> IndexArray;
>
>
> typedef sp1D_index_array<RepType> IndexArrayRef;
>
>
> typedef self subrange_type;
>
> friend class elt_ref<self>;
> friend class const_elt_ref<self>;
>
>
> inline iterator __find_set(int i) {
> rep_type_iterator pos = rep->lower_bound(entry_type(i));
> return iterator(pos);
> }
>
> inline iterator __find_normal(int i) {
> rep_type_iterator pos = lower_bound(rep->begin(), rep->end(),
> entry_type(i));
> return iterator(rep->begin(), pos);
> }
>
>protected:
>
> inline iterator find(int i) {
> return __sparseoned_find(this, i, rep.operator->());
> }
>
>
>
> inline const_iterator __find(int i, std::set<entry_type>*) const {
> const_rep_type_iterator pos = rep->lower_bound(entry_type(i));
> return const_iterator(pos);
> }
>
> template <class R>
> inline const_iterator __find(int i, R*) const {
> const_rep_type_iterator pos = lower_bound(rep->begin(), rep->end(),
> entry_type(i));
> return const_iterator(rep->begin(), pos);
> }
>
> inline const_iterator find(int i) const {
> return __find(i, rep.operator->());
> }
>
> inline iterator insert(iterator iter, int i, value_type v) {
> rep_type_iterator pos = rep->insert(iter.base(), entry_type(i, v));
> return iterator(rep->begin(), pos);
> }
>
>
>public:
>
>
>
>
> inline sparse1D()
> : rep(new ref_cont()), size_(0) { }
>
>
> inline sparse1D(size_type n)
> : rep(new ref_cont()), size_(n) { }
>
>
> inline sparse1D(const self& x)
> : rep(x.rep), size_(x.size_) { }
>
>
> template <class IndexArray>
> inline sparse1D(const IndexArray& x, size_type n)
> : rep(new ref_cont()), size_(n) {
> typename IndexArray::const_iterator i;
> for (i = x.begin(); i != x.end(); ++i)
> rep->push_back(entry_type(*i, value_type(0)));
> }
>
>
> inline self& operator=(const self& x) {
> rep = x.rep; size_ = x.size_; return *this;
> }
># 274 "/usr/local/include/mtl/sparse1D.h" 3
> inline iterator begin() {
> return iterator(rep->begin());
> }
>
>
> inline iterator end() {
> return iterator(rep->begin(), rep->end());
> }
>
>
> inline const_iterator begin() const {
> return const_iterator(rep->begin());
> }
>
>
> inline const_iterator end() const {
> return const_iterator(rep->begin(), rep->end());
> }
>
>
> inline reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
>
> inline reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
>
> inline const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
>
> inline const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
>
>
>
> inline const_reference operator[](int i) const {
> ;
> const_iterator iter = find(i);
> if (iter != end() && iter.index() == i)
> return *iter;
> else
> return value_type(0);
> }
>
>
> inline reference operator[](int i) {
> ;
> return reference(*this, i);
> }
>
>
>
> inline iterator insert(int i, const value_type& value) {
> ;
> rep_type_iterator pos = lower_bound(rep->begin(), rep->end(),
> entry_type(i));
> return rep->insert(pos, entry_type(i, value));
> }
>
> inline void clear() { rep->clear(); }
>
> inline void push_back(int i, const value_type& value) {
> ;
> rep->insert(rep->end(), entry_type(i, value));
> }
>
>
>
>
> inline int size() const {
> return size_;
> }
>
> inline int nnz() const {
> return rep->size();
> }
>
> inline void resize_imp(int n, std::set<entry_type>*) { }
>
> template <class R>
> inline void resize_imp(int n, R*) {
> rep->resize(n);
>
> }
>
>
> inline void resize(int n) {
> resize_imp(n, rep.operator->());
> }
>
>
> rep_type& get_rep() { return *rep; }
>
>
> inline void print() const {
> print_vector(*rep);
> }
>
> inline IndexArrayRef nz_struct() const {
> return IndexArrayRef(rep->begin(), rep->end());
> }
>
>protected:
>
> refcnt_ptr<rep_type> rep;
> size_type size_;
>};
>
>}
># 45 "/usr/local/include/mtl/matrix.h" 2 3
>
># 1 "/usr/local/include/mtl/uplo.h" 1 3
># 21 "/usr/local/include/mtl/uplo.h" 3
>namespace mtl {
>
>
>
>struct lower__;
>struct unit_lower__;
>
>
>
>struct upper__ {
> typedef lower__ transpose_type;
> std::pair<int,int> bandwidth(int, int n) { return std::make_pair(0, n); }
> bool is_upper() const { return true; }
> bool is_unit() const { return false; }
>};
>
>
>
>
>
>
>
>struct unit_upper__ {
> typedef unit_lower__ transpose_type;
> std::pair<int,int> bandwidth(int, int n) { return std::make_pair(-1, n); }
> bool is_upper() const { return true; }
> bool is_unit() const { return true; }
>};
>
>
>
>struct lower__ {
> typedef upper__ transpose_type;
> std::pair<int,int> bandwidth(int m, int) { return std::make_pair(m, 0); }
> bool is_upper() const { return false; }
> bool is_unit() const { return false; }
>};
>
>
>
>
>struct unit_lower__ {
> typedef unit_upper__ transpose_type;
> std::pair<int,int> bandwidth(int m, int) { return std::make_pair(m, -1); }
> bool is_upper() const { return false; }
> bool is_unit() const { return true; }
>};
>
>
>
>struct dynamic_uplo__ {
> typedef dynamic_uplo__ transpose_type;
> dynamic_uplo__(int uplo_) : uplo(uplo_) { }
> std::pair<int,int> bandwidth(int m, int n) const {
> std::pair<int,int> bw;
> switch (uplo) {
> case upper:
> bw = std::make_pair(0, n);
> break;
> case unit_upper:
> bw = std::make_pair(-1, n);
> break;
> case lower:
> bw = std::make_pair(m, 0);
> break;
> case unit_lower:
> bw = std::make_pair(m, -1);
> break;
> }
> return bw;
> }
> static std::pair<int,int> bandwidth(int uplo, int m, int n) {
> dynamic_uplo__ duplo(uplo);
> return duplo.bandwidth(m, n);
> }
> bool is_unit() const { return uplo == unit_upper || uplo == unit_lower; }
> bool is_upper() const { return uplo == upper || uplo == unit_upper; }
> int uplo;
>};
>
>}
># 47 "/usr/local/include/mtl/matrix.h" 2 3
>
>namespace mtl {
># 92 "/usr/local/include/mtl/matrix.h" 3
> template <int MM = 0, int NN = 0>
> class rectangle {
> public:
> enum { M = MM, N = NN, id = RECT, uplo };
> };
># 174 "/usr/local/include/mtl/matrix.h" 3
> template <int MemLoc=internal>
> struct banded {
> typedef int size_type;
> enum { id = BAND, oned_id, uplo, ext=MemLoc, M=0, N=0,
> issparse=0, index };
> };
># 197 "/usr/local/include/mtl/matrix.h" 3
> template <int MemLoc=internal>
> struct diagonal {
> enum { uplo, id = DIAG, ext=MemLoc, M=0, N=0 };
> };
># 262 "/usr/local/include/mtl/matrix.h" 3
> template <int Uplo = dynamic_uplo>
> struct triangle {
> enum { id = TRI, uplo = Uplo, M=0, N=0 };
> };
># 309 "/usr/local/include/mtl/matrix.h" 3
> template <int Uplo = dynamic_uplo>
> struct symmetric {
> enum { id = SYMM, uplo = Uplo, M=0, N=0 };
> };
>
>
>
>
>
>
>
> template <int Uplo = dynamic_uplo>
> struct hermitian {
> enum { id = HERM, uplo = Uplo, M=0, N=0 };
> };
>
>
>
>
> struct row_major {
> enum { id = ROW_MAJOR };
> };
>
>
>
> struct column_major {
> enum { id = COL_MAJOR };
> };
># 371 "/usr/local/include/mtl/matrix.h" 3
> template <int MemLoc=internal>
> struct dense {
> typedef int size_type;
> enum { id = DENSE, oned_id, ext=MemLoc, issparse=0, index };
> };
># 409 "/usr/local/include/mtl/matrix.h" 3
> template <int MemLoc=internal>
> struct packed {
> typedef int size_type;
> enum { id = PACKED, oned_id, ext=MemLoc, issparse=0, index };
> };
># 424 "/usr/local/include/mtl/matrix.h" 3
> template <int MemLoc=internal>
> struct banded_view {
> typedef int size_type;
> enum{id = BAND_VIEW,oned_id, ext=MemLoc, issparse=0, index };
> };
># 486 "/usr/local/include/mtl/matrix.h" 3
> template <class SizeType = int, int MemLoc=internal,
> int IndexStyle = index_from_zero>
> struct compressed {
> typedef SizeType size_type;
> enum { id = COMPRESSED, oned_id, ext=MemLoc,
> issparse=1, index=IndexStyle };
> };
># 545 "/usr/local/include/mtl/matrix.h" 3
> template <class OneD = dense<>, int MemLoc=internal>
> struct array {
> typedef typename OneD::size_type size_type;
> enum { id=ARRAY, oned_id=OneD::id, ext=MemLoc,
> issparse = OneD::issparse, index=index_from_zero };
> };
># 579 "/usr/local/include/mtl/matrix.h" 3
> template <int MemLoc=internal>
> struct envelope {
> typedef int size_type;
> enum { id = ENVELOPE, oned_id, ext=MemLoc, issparse = 0, index };
> };
># 595 "/usr/local/include/mtl/matrix.h" 3
> struct sparse_pair {
> typedef int size_type;
> enum { id = SPARSE_PAIR, issparse = 1, index=index_from_zero };
> };
># 608 "/usr/local/include/mtl/matrix.h" 3
> struct tree {
> typedef int size_type;
> enum { id = TREE, issparse = 1, index=index_from_zero};
> };
># 621 "/usr/local/include/mtl/matrix.h" 3
> struct linked_list {
> typedef int size_type;
> enum { id = LINKED_LIST, issparse = 1, index=index_from_zero };
> };
>
>
>
>
>
> struct generators_error { };
>
>
>
> template <class T, class Storage>
> struct generate_oned {
> enum { Storage_oned_id = Storage::oned_id,
> Storage_index = Storage::index };
> typedef typename IF< EQUAL< Storage_oned_id,DENSE>::RET,
> dense1D<T>,
> typename IF< EQUAL< Storage_oned_id,COMPRESSED>::RET,
> compressed1D<T, typename Storage::size_type,
> Storage_index>,
> typename IF< EQUAL< Storage_oned_id,SPARSE_PAIR>::RET,
> sparse1D< mtl::dense1D< entry1<T> > >,
> typename IF< EQUAL< Storage_oned_id,TREE>::RET,
> sparse1D< std::set< entry1<T> > >,
> typename IF< EQUAL< Storage_oned_id,LINKED_LIST>::RET,
> sparse1D< std::list< entry1<T> > >,
> generators_error
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Storage, int M, int N>
> struct generate_internal {
> enum { Storage_id = Storage::id, Storage_index = Storage::index };
> typedef typename IF< EQUAL< Storage_id, DENSE>::RET,
> gen_dense2D<T, gen_rect_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, COMPRESSED >::RET,
> gen_compressed2D<T, typename Storage::size_type,
> Storage_index,M,N>,
> typename IF< EQUAL< Storage_id, ENVELOPE >::RET,
> gen_envelope2D<T,M,N>,
> typename IF< EQUAL< Storage_id, PACKED >::RET,
> gen_dense2D<T, gen_packed_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, BAND >::RET,
> gen_dense2D<T, gen_banded_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, BAND_VIEW >::RET,
> gen_dense2D<T, gen_banded_view_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, ARRAY >::RET,
> gen_array2D< typename generate_oned<T,Storage>::RET >,
> generators_error
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Storage, int M, int N>
> struct generate_external {
> enum { Storage_id = Storage::id, Storage_index = Storage::index };
> typedef typename IF< EQUAL< Storage_id, DENSE>::RET,
> gen_external2D<T, gen_rect_offset<M,N>, M,N>,
> typename IF< EQUAL< Storage_id, COMPRESSED >::RET,
> gen_ext_comp2D<T, typename Storage::size_type,
> Storage_index,M,N>,
> typename IF< EQUAL< Storage_id, ENVELOPE >::RET,
> gen_envelope2D<T,M,N>,
> typename IF< EQUAL< Storage_id, PACKED >::RET,
> gen_external2D<T, gen_packed_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, BAND >::RET,
> gen_external2D<T, gen_banded_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, BAND_VIEW >::RET,
> gen_external2D<T, gen_banded_view_offset<M,N>,M,N>,
> typename IF< EQUAL< Storage_id, ARRAY >::RET,
> gen_array2D< typename generate_oned<T,Storage>::RET >,
> generators_error
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Storage, int M, int N>
> struct generate_storage {
> enum { Storage_ext = Storage::ext };
> typedef typename IF< Storage_ext,
> typename generate_external<T,Storage,M,N>::RET,
> typename generate_internal<T, Storage,M,N>::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Orientation, class Storage, int M, int N>
> struct generate_rect {
> enum { Orientation_id = Orientation::id };
> typedef typename generate_storage<T,Storage,M,N>::RET storage_t;
> typedef typename storage_t::type::size_type size_type;
> typedef typename IF< EQUAL<Orientation_id, ROW_MAJOR>::RET,
> row_matrix< storage_t,
> gen_rect_indexer<row_orien,M,N, size_type> >,
> typename IF< EQUAL<Orientation_id, COL_MAJOR>::RET,
> column_matrix< storage_t,
> gen_rect_indexer<column_orien,M,N,size_type> >,
> generators_error
> >::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Orientation, class Storage, int M, int N>
> struct generate_banded {
> enum { Orientation_id = Orientation::id };
> typedef typename generate_storage<T,Storage,M,N>::RET storage_t;
> typedef typename storage_t::type::size_type size_type;
> typedef typename IF< EQUAL<Orientation_id, ROW_MAJOR>::RET,
> row_matrix< storage_t,
> gen_banded_indexer<row_orien,M,N,size_type> >,
> typename IF< EQUAL<Orientation_id, COL_MAJOR>::RET,
> column_matrix< storage_t,
> gen_banded_indexer<column_orien,N,M,size_type> >,
> generators_error
> >::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Storage, int M, int N>
> struct generate_diagonal {
> typedef typename generate_storage<T,Storage,M,N>::RET storage_type;
> typedef typename storage_type::type::size_type size_type;
> typedef gen_diagonal_indexer<row_orien, M, N, size_type> indexer_gen;
> typedef diagonal_matrix<storage_type, indexer_gen> RET;
> };
>
>
>
> template <int Uplo>
> struct generate_uplo {
> typedef typename IF< EQUAL< Uplo, upper >::RET, upper__,
> typename IF< EQUAL< Uplo, unit_upper >::RET, unit_upper__,
> typename IF< EQUAL< Uplo, lower>::RET, lower__,
> typename IF< EQUAL< Uplo, unit_lower>::RET, unit_lower__,
>
>
>
> dynamic_uplo__
>
>
>
> >::RET
> >::RET
> >::RET
> >::RET RET;
> };
>
>
>
> template <class T, class Shape, class Orien, class Storage, int M, int N>
> struct generate_triangle {
> enum { Orien_id = Orien::id, Shape_uplo = Shape::uplo,
> Storage_issparse = Storage::issparse };
> typedef typename generate_storage<T,Storage,M,N>::RET storage_type;
> typedef typename storage_type::type::size_type size_type;
> typedef typename
> IF< Storage_issparse,
> typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
> triangle_matrix<row_matrix< storage_type,
> gen_banded_indexer<row_orien,M,N,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >,
> triangle_matrix<column_matrix< storage_type,
> gen_banded_indexer<column_orien,M,N,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >
> >::RET
> ,
> typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
> triangle_matrix<row_matrix< storage_type,
> gen_banded_indexer<row_orien,M,N,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >,
> triangle_matrix<column_matrix< storage_type,
> gen_banded_indexer<column_orien,M,N,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >
> >::RET
> >::RET RET;
> };
>
>
>
>
>
>
>
> template <class T, class Shape, class Orien, class Storage, int M, int N>
> struct generate_symmetric {
> enum { Shape_uplo = Shape::uplo, Orien_id = Orien::id,
> Storage_issparse = Storage::issparse };
> typedef typename generate_storage<T,Storage,M,N>::RET storage_type;
> typedef typename storage_type::type::size_type size_type;
> typedef typename
> IF< Storage_issparse,
> typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
> symmetric_matrix<row_matrix< storage_type,
> gen_rect_indexer<row_orien,M,N,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >,
> symmetric_matrix<column_matrix< storage_type,
> gen_rect_indexer<column_orien,N,M,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >
> >::RET
> ,
> typename IF< EQUAL< Orien_id, ROW_MAJOR>::RET,
> symmetric_matrix<row_matrix< storage_type,
> gen_banded_indexer<row_orien,M,N,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >,
> symmetric_matrix<column_matrix< storage_type,
> gen_banded_indexer<column_orien,N,M,size_type> >,
> typename generate_uplo<Shape_uplo>::RET >
> >::RET
> >::RET RET;
> };
># 913 "/usr/local/include/mtl/matrix.h" 3
> template < class T, class Shape = rectangle<>, class Storage = dense<>, class Orientation = row_major >
> struct matrix {
> enum { Shape_id = Shape::id, Shape_M = Shape::M, Shape_N = Shape::N };
>
> typedef typename IF< EQUAL< Shape_id, RECT>::RET,
> typename generate_rect<T,Orientation,Storage,
> Shape_M, Shape_N>::RET,
> typename IF< EQUAL< Shape_id, DIAG>::RET,
> typename generate_diagonal<T,Storage,
> Shape_M, Shape_N>::RET,
> typename IF< EQUAL< Shape_id, BAND>::RET,
> typename generate_banded<T,Orientation,Storage,
> Shape_M, Shape_N>::RET,
> typename IF< EQUAL< Shape_id, TRI>::RET,
> typename generate_triangle<T,Shape,
> Orientation,Storage,
> Shape_M, Shape_N>::RET,
> typename IF< EQUAL< Shape_id, SYMM>::RET,
> typename generate_symmetric<T,Shape,
> Orientation,Storage,
> Shape_M, Shape_N>::RET,
> generators_error
> >::RET
> >::RET
> >::RET
> >::RET
> >::RET type;
> };
># 1025 "/usr/local/include/mtl/matrix.h" 3
> template <class Matrix>
> struct band_view {
>
> typedef typename Matrix::banded_view_type type;
> };
># 1042 "/usr/local/include/mtl/matrix.h" 3
> template <class Matrix, int UL>
> struct triangle_view {
> typedef typename Matrix::sparsity Sparsity;
> enum { Sparsity_id = Sparsity::id };
>
> typedef typename generate_uplo<UL>::RET up_or_lower;
> typedef typename IF< EQUAL< Sparsity_id, DENSE>::RET,
> triangle_matrix<typename Matrix::banded_view_type, up_or_lower>,
> triangle_matrix< Matrix, up_or_lower >
> >::RET type;
> };
># 1061 "/usr/local/include/mtl/matrix.h" 3
> template <int Uplo>
> struct tri_view {
> template <class Matrix>
> inline typename triangle_view<Matrix, Uplo>::type operator()(Matrix x) const {
> typedef typename triangle_view<Matrix, Uplo>::type TriView;
> return TriView(x);
> }
> };
># 1082 "/usr/local/include/mtl/matrix.h" 3
> template <class Matrix, int Uplo>
> struct symmetric_view {
> typedef typename Matrix::sparsity Sparsity;
> enum { Sparsity_id = Sparsity::id };
>
> typedef typename IF< EQUAL< Sparsity_id, DENSE>::RET,
> symmetric_matrix< typename Matrix::banded_view_type,
> typename generate_uplo<Uplo>::RET>,
> symmetric_matrix< Matrix, typename generate_uplo<Uplo>::RET>
> >::RET type;
> };
>
>
>}
># 41 "/usr/local/include/mtl/mtl.h" 2 3
># 54 "/usr/local/include/mtl/mtl.h" 3
>namespace mtl {
>
>template <class T>
>inline T sign(const T& x) { return (x < 0) ? T(-1) : T(1); }
>
>template <class T>
>inline T xfer_sign(const T& x, const T& y)
>{
> return (y < 0) ? -std::abs(x) : std::abs(x);
>}
>
>
>
>class right_side { };
>
>
>
>class left_side { };
>
>
>
>template <class Vector> inline
>typename linalg_traits<Vector>::value_type
>sum__(const Vector& x, fast::count<0>)
>{
> typedef typename linalg_traits<Vector>::value_type vt;
> return mtl_algo::accumulate(x.begin(), x.end(), vt());
>}
># 101 "/usr/local/include/mtl/mtl.h" 3
>template <class Vector> inline
>typename linalg_traits<Vector>::value_type
>sum(const Vector& x)
>{
> return sum__(x, dim_n<Vector>::RET());
>}
>
>
>
>template <class S, class T, class R>
>struct mtl_multiplies : std::binary_function<S, T, R> {
> typedef S first_argument_type;
> typedef T second_argument_type;
> typedef R result_type;
> R operator () (const S& x, const T& y) const { return x * y; }
>};
>
>
>template <class Vector, class T> inline
>void
>oned_scale(Vector& x, const T& alpha, fast::count<0>)
>{
> typedef typename Vector::value_type VT;
> mtl_algo::transform(x.begin(), x.end(), x.begin(),
> std::bind1st(mtl_multiplies<T,VT,VT>(), alpha));
>}
># 138 "/usr/local/include/mtl/mtl.h" 3
>template <class Vector, class T> inline
>void
>scale_dim(Vector& x, const T& alpha, oned_tag)
>{
> oned_scale(x, alpha, dim_n<Vector>::RET());
>}
>
>template <class Matrix, class T>
>inline void
>scale_dim(Matrix& A, const T& alpha, twod_tag)
>{
> typename Matrix::iterator i;
> typename Matrix::OneD::iterator j, jend;
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> *j *= alpha;
> }
>}
># 172 "/usr/local/include/mtl/mtl.h" 3
>template <class LinalgObj, class T>
>inline void
>scale(const LinalgObj& A, const T& alpha)
>{
> typedef typename linalg_traits<LinalgObj>::dimension Dim;
> scale_dim(const_cast<LinalgObj&>(A), alpha, Dim());
>}
># 192 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix, class T>
>inline void
>set_diagonal(const Matrix& A_, const T& alpha)
>{
> Matrix& A = const_cast<Matrix&>(A_);
> typedef typename mtl::matrix_traits<Matrix>::size_type Int;
> if (! A.is_unit())
> for (Int i = 0; i < A.nrows() && i < A.ncols(); ++i)
> A(i,i) = alpha;
>}
>
>
>
>
>struct abs_add {
> template <class T, class U>
> T operator()(const T& a, const U& b) {
> return a + std::abs(b);
> }
>};
>
>template <class Vector>
>inline typename linalg_traits<Vector>::magnitude_type
>oned_one_norm(const Vector& x, fast::count<0>)
>{
> typedef typename linalg_traits<Vector>::magnitude_type T;
> return mtl_algo::accumulate(x.begin(), x.end(), T(), abs_add());
>}
># 232 "/usr/local/include/mtl/mtl.h" 3
>template <class Vector>
>inline typename linalg_traits<Vector>::magnitude_type
>one_norm(const Vector& x, oned_tag)
>{
> return oned_one_norm(x, dim_n<Vector>::RET());
>}
>
>
>
>
>struct sqr_add {
> template <class T, class U>
> T operator()(const T& a, const U& b) {
> return a + std::abs(b * b);
> }
>};
>
>template <class Vector>
>inline typename linalg_traits<Vector>::magnitude_type
>oned_two_norm(const Vector& x, fast::count<0>)
>{
> typedef typename Vector::value_type T;
> typedef typename number_traits<T>::magnitude_type M;
> using std::sqrt;
> return ::sqrt(mtl_algo::accumulate(x.begin(), x.end(), M(), sqr_add()));
>}
># 284 "/usr/local/include/mtl/mtl.h" 3
>template <class Vector>
>inline typename linalg_traits<Vector>::magnitude_type
>two_norm(const Vector& x)
>{
> return oned_two_norm(x, dim_n<Vector>::RET());
>}
>
>
>
>struct sqr_ {
> template <class T, class U>
> T operator()(const T& a, const U& b) {
> return a + std::abs(b * b);
> }
>};
># 307 "/usr/local/include/mtl/mtl.h" 3
>template <class Vector>
>inline typename linalg_traits<Vector>::value_type
>sum_squares(const Vector& x)
>{
> typedef typename linalg_traits<Vector>::value_type T;
> return mtl_algo::accumulate(x.begin(), x.end(), T(), sqr_add());
>}
>
>
>
>
>
>struct abs_cmp { template <class T>
>bool operator()(const T& a, const T& b) {
> return std::abs(a) < std::abs(b);
>}};
>
>
>template <class Vec>
>inline typename linalg_traits<Vec>::magnitude_type
>infinity_norm(const Vec& x, oned_tag)
>{
> return std::abs(*mtl_algo::max_element(x.begin(), x.end(), abs_cmp()));
>}
>
>
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>major_norm__(const Matrix& A)
>{
> typedef typename linalg_traits<Matrix>::magnitude_type T;
> typedef typename matrix_traits<Matrix>::size_type Int;
> T norm = 0;
> T sum = 0;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j;
> i = A.begin();
>
>
> if (i != A.end()) {
> j = (*i).begin();
> sum = T(0);
> for (; j != (*i).end(); ++j)
> sum = sum + std::abs(*j);
> norm = sum;
> ++i;
> }
>
> for (; i != A.end(); ++i) {
> j = (*i).begin();
> if (A.is_unit() && Int(i.index()) < std::min(A.nrows(),A.ncols()))
> sum = T(1);
> else sum = T(0);
>
> for (; j != (*i).end(); ++j)
> sum = sum + std::abs(*j);
> norm = std::max(std::abs(norm),std::abs(sum));
> }
> return norm;
>}
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>minor_norm__(const Matrix& A)
>{
> typedef typename linalg_traits<Matrix>::magnitude_type T;
> typedef typename matrix_traits<Matrix>::size_type Int;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> dense1D<T> sums(A.minor(), T());
> if (A.is_unit()) {
> for (Int x = 0; x < std::min(A.nrows(),A.ncols()); ++x)
> sums[x] = T(1);
> }
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> sums[j.index()] += std::abs(*j);
> }
>
> return infinity_norm(sums, oned_tag());
>}
>
>
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>symmetric_norm(const Matrix& A, row_tag)
>{
> typedef typename linalg_traits<Matrix>::magnitude_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> dense1D<T> sums(A.minor(), T(0));
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin();
> jend = (*i).end();
> if (A.is_upper()) {
> sums[j.row()] += std::abs(*j);
> ++j;
> } else
> --jend;
> for (; j != jend; ++j) {
> sums[j.row()] += std::abs(*j);
> sums[j.column()] += std::abs(*j);
> }
> if (A.is_lower())
> sums[j.row()] += std::abs(*j);
> }
> return infinity_norm(sums, oned_tag());
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>symmetric_norm(const Matrix& A, column_tag)
>{
> typedef typename linalg_traits<Matrix>::magnitude_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> dense1D<T> sums(A.minor(), T(0));
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin();
> jend = (*i).end();
> if (A.is_lower()) {
> sums[j.row()] += std::abs(*j);
> ++j;
> } else
> --jend;
> for (; j != jend; ++j) {
> sums[j.row()] += std::abs(*j);
> sums[j.column()] += std::abs(*j);
> }
> if (A.is_upper())
> sums[j.row()] += std::abs(*j);
> }
> return infinity_norm(sums, oned_tag());
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>symmetric_norm(const Matrix& A)
>{
> typedef typename matrix_traits<Matrix>::orientation Orien;
> return symmetric_norm(A, Orien());
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>diagonal_one_norm(const Matrix& A)
>{
> typedef typename linalg_traits<Matrix>::magnitude_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> dense1D<T> sums(A.ncols(), T(0));
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> sums[j.column()] += std::abs(*j);
> }
>
> return infinity_norm(sums);
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>diagonal_infinity_norm(const Matrix& A)
>{
> typedef typename linalg_traits<Matrix>::magnitude_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> dense1D<T> sums(A.nrows(), T(0));
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> sums[j.row()] += std::abs(*j);
> }
>
> return infinity_norm(sums);
>}
>
>
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>one_norm__(const Matrix& A, column_tag)
>{
> return major_norm__(A);
>}
>
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>one_norm__(const Matrix& A, row_tag)
>{
> return minor_norm__(A);
>}
>
>
>template <class Matrix, class Shape>
>inline typename linalg_traits<Matrix>::magnitude_type
>twod_one_norm(const Matrix& A, Shape)
>{
> typedef typename Matrix::orientation Orien;
> return one_norm__(A, Orien());
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>twod_one_norm(const Matrix& A, symmetric_tag)
>{
> return symmetric_norm(A);
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>twod_one_norm(const Matrix& A, diagonal_tag)
>{
> return diagonal_one_norm(A);
>}
>
>
>template <class Linalg>
>inline typename linalg_traits<Linalg>::magnitude_type
>one_norm(const Linalg& A, twod_tag)
>{
> typedef typename matrix_traits<Linalg>::shape Shape;
> return twod_one_norm(A, Shape());
>}
># 571 "/usr/local/include/mtl/mtl.h" 3
>template <class LinalgObj>
>inline typename linalg_traits<LinalgObj>::magnitude_type
>one_norm(const LinalgObj& A)
>{
> typedef typename linalg_traits<LinalgObj>::dimension Dim;
> return one_norm(A, Dim());
>}
>
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>infinity_norm__(const Matrix& A, row_tag)
>{
> return major_norm__(A);
>}
>
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>infinity_norm__(const Matrix& A, column_tag)
>{
> return minor_norm__(A);
>}
>
>template <class Matrix, class Shape>
>inline typename linalg_traits<Matrix>::magnitude_type
>twod_infinity_norm(const Matrix& A, Shape)
>{
> typedef typename Matrix::orientation Orien;
> return infinity_norm__(A, Orien());
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>twod_infinity_norm(const Matrix& A, symmetric_tag)
>{
> return symmetric_norm(A);
>}
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>twod_infinity_norm(const Matrix& A, diagonal_tag)
>{
> return diagonal_infinity_norm(A);
>}
>
>
>template <class Matrix>
>inline typename linalg_traits<Matrix>::magnitude_type
>infinity_norm(const Matrix& A, twod_tag)
>{
> typedef typename matrix_traits<Matrix>::shape Shape;
> return twod_infinity_norm(A, Shape());
>}
># 643 "/usr/local/include/mtl/mtl.h" 3
>template <class LinalgObj>
>inline typename linalg_traits<LinalgObj>::magnitude_type
>infinity_norm(const LinalgObj& A)
>{
> typedef typename linalg_traits<LinalgObj>::dimension Dim;
> return infinity_norm(A, Dim());
>}
># 660 "/usr/local/include/mtl/mtl.h" 3
>template <class Vec>
>inline typename Vec::size_type
>max_index(const Vec& x)
>{
> typename Vec::const_iterator maxi =
> mtl_algo::max_element(x.begin(), x.end(), abs_cmp());
> return maxi.index();
>}
># 681 "/usr/local/include/mtl/mtl.h" 3
>template <class Vec>
>inline typename Vec::size_type
>max_abs_index(const Vec& x)
>{
> typename Vec::const_iterator maxi =
> mtl_algo::max_element(x.begin(), x.end(), abs_cmp());
> return maxi.index();
>}
># 699 "/usr/local/include/mtl/mtl.h" 3
>template<class Vec>
>inline typename Vec::size_type
>min_index(const Vec& x)
>{
> typename Vec::const_iterator mini =
> mtl_algo::min_element(x.begin(), x.end());
> return mini.index();
>}
># 719 "/usr/local/include/mtl/mtl.h" 3
>template<class Vec>
>inline typename Vec::size_type
>min_abs_index(const Vec& x)
>{
> typename Vec::const_iterator mini =
> mtl_algo::min_element(x.begin(), x.end(), abs_cmp());
> return mini.index();
>}
># 737 "/usr/local/include/mtl/mtl.h" 3
>template <class VectorT>
>inline typename VectorT::value_type
>max(const VectorT& x)
>{
> return *mtl_algo::max_element(x.begin(), x.end());
>}
># 752 "/usr/local/include/mtl/mtl.h" 3
>template <class VectorT>
>inline typename VectorT::value_type
>min(const VectorT& x)
>{
> return *mtl_algo::min_element(x.begin(), x.end());
>}
># 782 "/usr/local/include/mtl/mtl.h" 3
>template <class T>
>class givens_rotation {
>public:
>
>
> inline givens_rotation()
> :
>
> a_(0), b_(0),
>
> c_(0), s_(0)
>
>
>
> { }
>
>
> inline givens_rotation(T a_in, T b_in) {
>
> T roe;
> if (std::abs(a_in) > std::abs(b_in))
> roe = a_in;
> else
> roe = b_in;
>
> T scal = std::abs(a_in) + std::abs(b_in);
> T r, z;
> if (scal != T(0)) {
> T a_scl = a_in / scal;
> T b_scl = b_in / scal;
> r = scal * sqrt(a_scl * a_scl + b_scl * b_scl);
> if (roe < T(0)) r *= -1;
> c_ = a_in / r;
> s_ = b_in / r;
> z = 1;
> if (std::abs(a_in) > std::abs(b_in))
> z = s_;
> else if (std::abs(b_in) >= std::abs(a_in) && c_ != T(0))
> z = T(1) / c_;
> } else {
> c_ = 1; s_ = 0; r = 0; z = 0;
> }
> a_ = r;
> b_ = z;
># 859 "/usr/local/include/mtl/mtl.h" 3
> }
>
> inline void set_cs(T cin, T sin) { c_ = cin; s_ = sin; }
>
>
> inline void scalar_apply(T& x, T& y) {
> T tmp = c_ * x + s_ * y;
> y = c_ * y - s_ * x;
> x = tmp;
> }
>
>
> template <class VecX, class VecY>
> inline void apply(const VecX& x_, const VecY& y_) {
> VecX& x = const_cast<VecX&>(x_);
> VecY& y = const_cast<VecY&>(y_);
>
> ;
>
> typename VecX::iterator xi = x.begin();
> typename VecX::iterator xend = x.end();
> typename VecY::iterator yi = y.begin();
>
> while (mtl::not_at(xi, xend)) {
> scalar_apply(*xi, *yi);
> ++xi; ++yi;
> }
> }
>
>
> inline T a() { return a_; }
> inline T b() { return b_; }
>
> inline T c() { return c_; }
> inline T s() { return s_; }
>
>
>
>protected:
>
> T a_, b_;
>
> T c_, s_;
>
>
>
>};
>
>using std::real;
>using std::imag;
>
>
>
>
>
>
>
>template <class T>
>class givens_rotation < std::complex<T> > {
> typedef std::complex<T> C;
>public:
>
> inline givens_rotation() : cs(0), sn(0)
>
>
>
> { }
>
> inline T abs_sq(C t) { return real(t) * real(t) + imag(t) * imag(t); }
> inline T abs1(C t) { return std::abs(real(t)) + std::abs(imag(t)); }
>
>
> inline givens_rotation(C a_in, C b_in) {
>
> T a = std::abs(a_in), b = std::abs(b_in);
> if ( a == T(0) ) {
> cs = T(0);
> sn = C(1.);
>
> } else {
> T scale = a + b;
> T norm = std::sqrt(abs_sq(a_in/scale)+abs_sq(b_in/scale)) * scale;
>
> cs = a / norm;
> sn = a_in/a * std::conj(b_in)/norm;
>
> }
># 986 "/usr/local/include/mtl/mtl.h" 3
> }
>
> template <class VecX, class VecY>
> inline void apply(const VecX& x_, const VecY& y_) {
> VecX& x = const_cast<VecX&>(x_);
> VecY& y = const_cast<VecY&>(y_);
>
> ;
>
> typename VecX::iterator xi = x.begin();
> typename VecX::iterator xend = x.end();
> typename VecY::iterator yi = y.begin();
>
> while (mtl::not_at(xi, xend)) {
> scalar_apply(*xi, *yi);
> ++xi; ++yi;
> }
> }
>
> inline void scalar_apply(C& x, C& y) {
> complex<T> temp = std::conj(cs) * x + std::conj(sn) * y;
> y = cs * y - sn * x;
> x = temp;
> }
> inline void set_cs(const T& cs_, const C& sn_) {
> cs = cs_; sn = sn_;
> }
>
> inline T c() { return cs; }
> inline C s() { return sn; }
>
>
>
>
>protected:
> T cs;
> C sn;
>
>
>
>};
># 1262 "/usr/local/include/mtl/mtl.h" 3
>template <class T>
>class modified_givens {
>
>};
>
>
>template <class T>
>inline T two_norm3(const T& x, const T& y, const T& z) {
> return sqrt(x*x + y*y + z*z);
>}
>
>
>
>
>
>
>template <class T, class Vec>
>inline void generate_householder(T& alpha, const Vec& x,
> Vec& v, T& tau)
>{
> ;
> typedef typename number_traits<T>::magnitude_type Real;
> typename Vec::subrange_type subx = x(0, x.size() - 1);
> typename Vec::subrange_type subv = v(0, v.size() - 1);
> v[v.size() - 1] = x[x.size() - 1];
> Real xnorm = two_norm(x);
> Real alpha_r = real(alpha);
> Real alpha_i = imag(alpha);
>
> if (xnorm == Real(0) && alpha_i == Real(0))
> tau = T(0);
> else {
> Real beta = -xfer_sign(two_norm3(alpha_r, alpha_i, xnorm), alpha_r);
> Real safe_min = std::numeric_limits<Real>::min();
> Real r_safe_min = Real(1) / safe_min;
>
> int count = 0;
> while (std::abs(beta) < safe_min) {
> if (count == 0)
> copy(mtl::scaled(subx, r_safe_min), subv);
> else
> scale(subv, r_safe_min);
> beta *= r_safe_min;
> alpha *= r_safe_min;
> ++count;
> }
> if (count != 0) {
> alpha_r = real(alpha);
> alpha_i = imag(alpha);
> xnorm = two_norm(x);
> beta = -xfer_sign(two_norm3(alpha_r, alpha_i, xnorm), alpha_r);
> }
> tau = beta - (alpha / beta);
> alpha = T(1) / (alpha - beta);
> scale(subv, alpha);
> alpha = beta;
> for (int j = 0; j < count; ++j)
> alpha *= safe_min;
> }
>}
>
>
>
>
>
>
>
>template <class T>
>class householder_transform {
> typedef typename number_traits<T>::magnitude_type Real;
> typedef dense1D<T> Vec;
>public:
> template <class Vec>
> inline householder_transform(const T& alpha, Vec& x, const T& tau)
> : _alpha(alpha), _v(x.size()), _tau(tau) {
> generate_householder(_alpha, x, _v, _tau);
> }
># 1362 "/usr/local/include/mtl/mtl.h" 3
>protected:
> T _alpha;
> Vec _v;
> T _tau;
>};
># 1376 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix>
>inline void
>transpose(const Matrix& A_)
>{
> Matrix& A = const_cast<Matrix&>(A_);
> ;
> typedef typename matrix_traits<Matrix>::value_type T;
> typedef typename mtl::matrix_traits<Matrix>::size_type Int;
> for (Int i = 0; i < A.nrows(); ++i)
> for (Int j = i; j < A.ncols(); ++j) {
> T tmp = A(i, j);
> A(i, j) = A(j, i);
> A(j, i) = tmp;
> }
>}
># 1406 "/usr/local/include/mtl/mtl.h" 3
>template <class MatA, class MatB>
>inline void
>transpose(const MatA& A, const MatB& B_)
>{
> MatB& B = const_cast<MatB&>(B_);
> ;
> ;
>
> typename MatA::const_iterator i;
> typename MatA::OneD::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> B(j.column(), j.row()) = *j;
> }
>}
># 1440 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_generic__(const Matrix& A, const VecX& xx, VecZ& zz)
>{
> ;
> ;
> typedef typename matrix_traits<Matrix>::value_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
> typename VecX::const_iterator x = xx.begin();
> typename VecZ::iterator z = zz.begin();
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> z[j.row()] += *j * x[j.column()];
> }
>}
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_shape__(const Matrix& A, const VecX& x, VecZ& z,
> banded_tag)
>{
> mult_generic__(A, x, z);
>}
>
>
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>rect_mult(const Matrix& A, const VecX& xx, VecZ& zz,
> row_tag, dense_tag)
>{
> ;
> ;
> typedef typename matrix_traits<Matrix>::value_type T;
> typename Matrix::const_iterator i, iend;
> typename Matrix::OneD::const_iterator j, jend;
> typename VecX::const_iterator x = xx.begin();
> typename VecZ::iterator z = zz.begin();
>
> i = A.begin();
> iend = A.end();
> for (; i != iend; ++i) {
> j = (*i).begin(); jend = (*i).end();
> T tmp = z[j.row()];
> for (; j != jend; ++j)
> tmp += *j * x[j.column()];
> z[j.row()] = tmp;
> }
>}
>
>
>
>
>
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>rect_mult(const Matrix& A, const VecX& xx, VecZ& zz,
> column_tag, dense_tag)
>{
> ;
> ;
> typedef typename matrix_traits<Matrix>::value_type T;
> typedef typename matrix_traits<Matrix>::size_type Int;
> typename VecX::const_iterator x = xx.begin();
> typename VecZ::iterator z = zz.begin();
>
> typename Matrix::const_iterator i, iend;
> typename Matrix::OneD::const_iterator j, jend;
> i = A.begin();
> iend = A.end();
> for (; i != iend; ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> z[j.row()] += *j * x[j.column()];
> }
>}
>
>
>
>template <class Matrix, class VecX, class VecY>
>void
>rect_mult(const Matrix& A, const VecX& x, VecY& y,
> column_tag, sparse_tag)
>{
> typename VecX::const_iterator xi = x.begin();
> for (; xi != x.end(); ++xi) {
> mtl::add(mtl::scaled(A[xi.index()], *xi), y);
> }
>}
>
>
>
>template <class Matrix, class VecX, class VecY>
>void
>rect_mult(const Matrix& A, const VecX& x, VecY& y,
> row_tag, sparse_tag)
>{
> typename Matrix::const_iterator Ai;
> for (Ai = A.begin(); Ai != A.end(); ++Ai) {
> y[Ai.index()] = mtl::dot(*Ai, x);
> }
>}
>
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_shape__(const Matrix& A, const VecX& x, VecZ z,
> rectangle_tag)
>{
> typedef typename matrix_traits<Matrix>::orientation Orien;
> typedef typename linalg_traits<VecX>::sparsity SparseX;
> rect_mult(A, x, z, Orien(), SparseX());
>}
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_shape__(const Matrix& A, const VecX& x, VecZ& z,
> triangle_tag)
>{
> mult_shape__(A, x, z, rectangle_tag());
> if (A.is_unit()) {
>
>
>
>
>
> if (z.size() <= x.size())
> mtl::add(z, x, z);
> else
> mtl::add(x, z, z);
> }
>}
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_symm__(const Matrix& A, const VecX& x, VecZ& z, row_tag)
>{
> typedef typename matrix_traits<Matrix>::value_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> T tmp = z[i.index()];
> j = (*i).begin();
> jend = (*i).end();
> if (A.is_upper()) {
> tmp += *j * x[j.column()];
> ++j;
> } else
> --jend;
> for (; j != jend; ++j) {
>
> tmp += *j * x[j.column()];
>
> z[j.column()] += *j * x[j.row()];
> }
> if (A.is_lower())
> tmp += *j * x[j.column()];
> z[i.index()] = tmp;
> }
>}
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_symm__(const Matrix& A, const VecX& x, VecZ& z, column_tag)
>{
> typedef typename matrix_traits<Matrix>::value_type T;
> typename Matrix::const_iterator i;
> typename Matrix::OneD::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> T tmp = T(0);
> j = (*i).begin();
> jend = (*i).end();
> if (A.is_lower()) {
> z[j.column()] += *j * x[j.column()];
> ++j;
> } else
> --jend;
> for (; j != jend; ++j) {
>
> z[j.row()] += *j * x[j.column()];
>
> tmp += *j * x[j.row()];
> }
> if (A.is_upper())
> tmp += *j * x[j.row()];
> z[i.index()] += tmp;
> }
>}
>
>
>template <class Matrix, class VecX, class VecZ>
>inline void
>mult_shape__(const Matrix& A, const VecX& x, VecZ& z,
> symmetric_tag)
>{
> typedef typename matrix_traits<Matrix>::orientation Orien;
> mult_symm__(A, x, z, Orien());
>}
># 1657 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix, class VecX, class VecY, class VecZ>
>inline void
>mult(const Matrix& A, const VecX& x, const VecY& y, const VecZ& z_)
> 
>{
> VecZ& z = const_cast<VecZ&>(z_);
> mtl::copy(y, z);
> typedef typename matrix_traits<Matrix>::shape Shape;
> mult_shape__(A, x, z, Shape());
>}
># 1687 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix, class VecX, class VecY>
>inline void
>mult_dim__(const Matrix& A, const VecX& x, VecY& y, oned_tag)
>{
> mtl::mult(A, x, mtl::scaled(y, 0), y);
>
>
>
>
>}
>
>template <class Matrix, class VecX, class VecY>
>inline void
>mult_add(const Matrix& A, const VecX& x, const VecY& y_)
>{
> VecY& y = const_cast<VecY&>(y_);
> typedef typename matrix_traits<Matrix>::shape Shape;
> mult_shape__(A, x, y, Shape());
>}
>
>
>
>
>template <class MatA, class MatB, class MatC, class Orien>
>inline void
>simple_mult(const MatA& A, const MatB& B, MatC& C, dense_tag, Orien)
>{
> typedef typename matrix_traits<MatA>::size_type Int;
> typename MatA::const_iterator A_k;
> typename MatA::OneD::const_iterator A_ki;
>
> A_k = A.begin();
> while (not_at(A_k, A.end())) {
> for (Int j = 0; j < B.ncols(); ++j) {
> A_ki = (*A_k).begin();
> while (not_at(A_ki, (*A_k).end())) {
> Int k = A_ki.column();
> Int i = A_ki.row();
> C(i,j) += *A_ki * B(k,j);
> ++A_ki;
> }
> }
> ++A_k;
> }
>}
>
>
>template <class MatrixA, class MatrixB, class MatrixC>
>inline void
>simple_mult(const MatrixA& A, const MatrixB& B, MatrixC& C,
> sparse_tag, row_tag)
>{
> typedef typename matrix_traits<MatrixA>::value_type T;
> typedef typename matrix_traits<MatrixA>::size_type Int;
> T scal;
> Int len = 0;
> Int jj, k;
> Int nzmax = C.capacity();
>
> Int M = A.nrows();
> Int N = B.ncols();
>
> dense1D<Int> ic(M + 1, 0);
> dense1D<Int> jc(nzmax);
> dense1D<T> c(nzmax);
>
> typedef typename dense1D<Int>::iterator di_iter;
> typedef typename dense1D<T>::iterator dt_iter;
>
> compressed1D<T> tmp1(N), tmp2(N), tmp3(N);
> tmp1.reserve(N);
> tmp2.reserve(N);
>
> typedef typename compressed1D<T>::iterator tmpiter;
>
> typename MatrixA::const_iterator Ai;
> typename MatrixA::Row::const_iterator Aij;
>
> for (Ai = A.begin(); Ai != A.end(); ++Ai) {
>
> copy(C[Ai.index()], tmp1);
>
> for (Aij = (*Ai).begin(); Aij != (*Ai).end(); ++Aij) {
> scal = *Aij;
> jj = Aij.column();
>
> add(mtl::scaled(B[jj], scal), tmp1, tmp2);
> tmp1.clear();
>
> tmp3 = tmp1; tmp1 = tmp2; tmp2 = tmp3;
> }
>
> k = len;
> if (k + tmp1.nnz() > nzmax) {
> std::cerr << "Not enough work space, increase capacity of C" << std::endl;
> return;
> }
> for (tmpiter t = tmp1.begin(); t != tmp1.end(); ++t, ++k) {
> c[k] = *t;
> jc[k] = t.index();
> }
>
> len += tmp1.nnz();
> ic[Ai.index() + 1] = len;
> }
> typedef typename matrix<T, rectangle<>,
> compressed<Int, external>,
> row_major>::type SpMat;
> SpMat CC(M, N, len, c.data(), ic.data(), jc.data());
> copy(CC, C);
>}
>
>
>template <class MatrixA, class MatrixB, class MatrixC>
>inline void
>simple_mult(const MatrixA& A, const MatrixB& B, MatrixC& C,
> sparse_tag, column_tag)
>{
> typedef typename matrix_traits<MatrixA>::value_type T;
> typedef typename matrix_traits<MatrixA>::size_type Int;
> T scal;
> Int len = 0;
> Int kk, k;
> Int nzmax = C.capacity();
>
> Int M = A.nrows();
> Int N = B.ncols();
>
> dense1D<Int> ic(N + 1, 0);
> dense1D<Int> jc(nzmax);
> dense1D<T> c(nzmax);
>
> typedef typename dense1D<Int>::iterator di_iter;
> typedef typename dense1D<T>::iterator dt_iter;
>
> compressed1D<T> tmp1(M), tmp2(M), tmp3(M);
> tmp1.reserve(M);
> tmp2.reserve(M);
>
> typedef typename compressed1D<T>::iterator tmpiter;
>
> typename MatrixB::const_iterator Bj;
> typename MatrixB::Column::const_iterator Bjk;
>
> for (Bj = B.begin(); Bj != B.end(); ++Bj) {
>
> copy(C[Bj.index()], tmp1);
>
> for (Bjk = (*Bj).begin(); Bjk != (*Bj).end(); ++Bjk) {
> scal = *Bjk;
> kk = Bjk.row();
>
> add(mtl::scaled(A[kk], scal), tmp1, tmp2);
> tmp1.clear();
>
> tmp3 = tmp1; tmp1 = tmp2; tmp2 = tmp3;
> }
>
> k = len;
> if (k + tmp1.nnz() > nzmax) {
> std::cerr << "Not enough work space, increase capacity of C" << std::endl;
> return;
> }
> for (tmpiter t = tmp1.begin(); t != tmp1.end(); ++t, ++k) {
> c[k] = *t;
> jc[k] = t.index();
> }
>
> len += tmp1.nnz();
> ic[Bj.index() + 1] = len;
> }
>
> typedef typename matrix<T, rectangle<>,
> compressed<Int, external>,
> column_major>::type SpMat;
> SpMat CC(M, N, len, c.data(), ic.data(), jc.data());
> copy(CC, C);
>}
>
>
>
>
>template <class MatA, class MatB, class MatC>
>inline void
>symm_simple_mult(const MatA& A, const MatB& B, MatC& C, row_tag)
>{
> typedef typename matrix_traits<MatA>::size_type Int;
> typename MatA::const_iterator A_k;
> typename MatA::OneD::const_iterator A_ki, A_kiend;
>
> A_k = A.begin();
> while (not_at(A_k, A.end())) {
> for (Int j = 0; j < B.ncols(); ++j) {
> A_ki = (*A_k).begin();
> A_kiend = (*A_k).end();
>
> Int k = A_ki.column();
> Int i = A_ki.row();
>
> if (A.is_upper()) {
> C(i,j) += *A_ki * B(k,j);
> ++A_ki;
> } else
> --A_kiend;
>
> while (not_at(A_ki, A_kiend)) {
> k = A_ki.column();
> i = A_ki.row();
> C(i,j) += *A_ki * B(k,j);
> C(k,j) += *A_ki * B(i,j);
> ++A_ki;
> }
> k = A_ki.column();
> i = A_ki.row();
> if (A.is_lower())
> C(i,j) += *A_ki * B(k,j);
>
> }
> ++A_k;
> }
>}
>
>
>
>template <class MatA, class MatB, class MatC>
>inline void
>symm_simple_mult(const MatA& A, const MatB& B, MatC& C, column_tag)
>{
> typedef typename matrix_traits<MatA>::size_type Int;
> typename MatA::const_iterator A_k;
> typename MatA::OneD::const_iterator A_ki, A_kiend;
>
> A_k = A.begin();
> while (not_at(A_k, A.end())) {
> for (Int j = 0; j < B.ncols(); ++j) {
> A_ki = (*A_k).begin();
> A_kiend = (*A_k).end();
>
> Int k = A_ki.column();
> Int i = A_ki.row();
>
> if (A.is_lower()) {
> C(i,j) += *A_ki * B(k,j);
> ++A_ki;
> } else
> --A_kiend;
>
> while (not_at(A_ki, A_kiend)) {
> k = A_ki.column();
> i = A_ki.row();
> C(i,j) += *A_ki * B(k,j);
> C(k,j) += *A_ki * B(i,j);
> ++A_ki;
> }
> k = A_ki.column();
> i = A_ki.row();
> if (A.is_upper())
> C(i,j) += *A_ki * B(k,j);
> }
>
> ++A_k;
> }
>}
>
>
>
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, symmetric_tag)
>{
> typedef typename matrix_traits<MatA>::orientation Orien;
> symm_simple_mult(A, B, C, Orien());
>}
>
>
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, triangle_tag)
>{
> typedef typename matrix_traits<MatA>::size_type Int;
> typedef typename matrix_traits<MatA>::orientation Orien;
> if (A.is_unit()) {
> Int M = std::min(A.nrows(),A.ncols());
> Int N = B.ncols();
> for (Int i = 0; i < M; ++i)
> for (Int j = 0; j < N; ++j)
> C(i,j) += B(i,j);
> }
>
> simple_mult(A, B, C, mtl::dense_tag(), Orien());
>}
>
>
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, rectangle_tag)
>{
> typedef typename matrix_traits<MatA>::sparsity Sparsity;
> typedef typename matrix_traits<MatA>::orientation Orien;
> simple_mult(A, B, C, Sparsity(), Orien());
>}
>
>template <class MatA, class MatB, class MatC>
>inline void
>matmat_mult(const MatA& A, const MatB& B, MatC& C, banded_tag)
>{
> typedef typename matrix_traits<MatC>::sparsity Sparsity;
> typedef typename matrix_traits<MatA>::orientation Orien;
> simple_mult(A, B, C, Sparsity(), Orien());
>}
># 2025 "/usr/local/include/mtl/mtl.h" 3
>template <class MatA, class MatB, class MatC>
>inline void
>mult_dim__(const MatA& A, const MatB& B, MatC& C, twod_tag)
>{
> typedef typename MatA::shape Shape;
> matmat_mult(A, B, C, Shape());
>}
>
>
>
>
>template <class LinalgA, class LinalgB, class LinalgC>
>inline void
>mult(const LinalgA& A, const LinalgB& B, const LinalgC& C_)
>{
> LinalgC& C = const_cast<LinalgC&>(C_);
> typedef typename linalg_traits<LinalgB>::dimension Dim;
> mult_dim__(A, B, C, Dim());
>}
>
>
>
>template <class TriMatrix, class VecX>
>inline void
>tri_solve__(const TriMatrix& T, VecX& x, column_tag)
>{
> typedef typename matrix_traits<TriMatrix>::size_type Int;
> typedef typename matrix_traits<TriMatrix>::value_type VT;
> typename VecX::value_type x_j;
>
> if (T.is_upper()) {
> typename TriMatrix::const_reverse_iterator T_j;
> typename TriMatrix::Column::const_reverse_iterator T_ji, T_jrend;
>
> for (T_j = T.rbegin(); T_j != T.rend(); ++T_j) {
> T_ji = (*T_j).rbegin();
> T_jrend = (*T_j).rend();
>
> Int j = T_j.index();
>
>
>
> if ( (T_ji != T_jrend) && ! T.is_unit()) {
> x[j] /= *T_ji;
> ++T_ji;
> }
> x_j = x[j];
>
> while (T_ji != T_jrend) {
> Int i = T_ji.row();
> x[i] -= x_j * *T_ji;
> ++T_ji;
> }
> }
> } else {
> typename TriMatrix::const_iterator T_j;
> typename TriMatrix::Column::const_iterator T_ji, T_jend;
>
> for (T_j = T.begin(); T_j != T.end(); ++T_j) {
> T_ji = (*T_j).begin();
> T_jend = (*T_j).end();
>
> Int j = T_j.index();
>
> if ( (T_ji != T_jend) && ! T.is_unit()) {
> x[j] /= *T_ji;
> ++T_ji;
> }
> x_j = x[j];
>
> while (T_ji != T_jend) {
> Int i = T_ji.row();
> x[i] -= x_j * *T_ji;
> ++T_ji;
> }
> }
> }
>}
>
>
>
>template <class TriMatrix, class VecX>
>inline void
>tri_solve__(const TriMatrix& T, VecX& x, row_tag)
>{
> typedef typename matrix_traits<TriMatrix>::value_type VT;
> typedef typename matrix_traits<TriMatrix>::size_type Int;
>
> if (T.is_upper()) {
> typename TriMatrix::const_reverse_iterator T_i, T_iend;
> typename TriMatrix::Row::const_reverse_iterator T_ij;
>
> T_i = T.rbegin();
> T_iend = T.rend();
>
> if ( (T_i != T_iend) && ! T.is_unit()) {
> T_ij = (*T_i).rbegin();
> x[T_ij.row()] /= *T_ij;
> ++T_i;
> }
>
> while (T_i != T_iend) {
> T_ij = (*T_i).rbegin();
>
> Int i = T_i.index();
> VT t = x[i];
>
> typename TriMatrix::Row::const_reverse_iterator T_iend;
> T_iend = (*T_i).rend();
> if ( (T_ij != T_iend) && ! T.is_unit())
> --T_iend;
>
> Int j;
> while (T_ij != T_iend) {
> j = T_ij.column();
> t -= (*T_ij) * x[j];
> ++T_ij;
> }
> if ( (*T_i).rbegin() != (*T_i).rend() && !T.is_unit())
> t /= *T_ij;
>
> x[i] = t;
>
> ++T_i;
> }
> } else {
>
> typename TriMatrix::const_iterator T_i;
> typename TriMatrix::Row::const_iterator T_ij;
>
> T_i = T.begin();
>
> if (T_i != T.end() && ! T.is_unit()) {
> T_ij = (*T_i).begin();
> x[T_ij.row()] *= VT(1) / *T_ij;
> ++T_i;
> }
>
> while (T_i != T.end()) {
> T_ij = (*T_i).begin();
>
> Int i = T_i.index();
> VT t = x[i];
>
> typename TriMatrix::Row::const_iterator T_iend;
> T_iend = (*T_i).end();
> if ( ( T_ij != T_iend ) && ! T.is_unit())
> --T_iend;
>
> Int j;
> while (T_ij != T_iend) {
> j = T_ij.column();
> t -= (*T_ij) * x[j];
> ++T_ij;
> }
> if ( (*T_i).begin() !=(*T_i).end() && !T.is_unit())
> t /= *T_ij;
>
> x[i] = t;
> ++T_i;
> }
> }
>}
># 2207 "/usr/local/include/mtl/mtl.h" 3
>template <class TriMatrix, class VecX>
>inline void
>tri_solve(const TriMatrix& T, const VecX& x_)
>{
> VecX& x = const_cast<VecX&>(x_);
> ;
> ;
> ;
> typedef typename TriMatrix::orientation orien;
> tri_solve__(T, x, orien());
>}
>
>
>
>
>
>
>
>template <class MatT, class MatB>
>inline void
>tri_solve__(const MatT& T, MatB& B, left_side)
>{
>
> const int N = B.ncols();
>
>
> for (int j = 0; j < B.ncols(); ++j)
> mtl::tri_solve(T, columns(B)[j]);
># 2259 "/usr/local/include/mtl/mtl.h" 3
>}
>
>
>
>
>
>
>template <class MatT, class MatB>
>inline void
>tri_solve__(const MatT& T, MatB& B, right_side)
>{
> const int M = B.nrows();
> const int N = B.ncols();
> typedef typename MatT::PR PR;
>
> if (T.is_upper()) {
> for (int j = 0; j < N; ++j) {
> for (int k = 0; k < j; ++k)
> if (T(k,j) != PR(0))
> for (int i = 0; i < M; ++i)
> B(i,j) -= T(k,j) * B(i,k);
> if (! T.is_unit()) {
> PR tmp = PR(1) / T(j,j);
> for (int i = 1; i < M; ++i)
> B(i,j) = tmp * B(i,j);
> }
> }
> } else {
> for (int j = N - 1; j > 0; --j) {
> for (int k = j; k < N; ++k)
> if (T(k,j) != PR(0))
> for (int i = 0; i < M; ++i)
> B(i,j) -= T(k,j) * B(i,k);
> if (! T.is_unit()) {
> PR tmp = PR(1) / T(j,j);
> for (int i = 1; i < M; ++i)
> B(i,j) = tmp * B(i,j);
> }
> }
> }
>}
># 2320 "/usr/local/include/mtl/mtl.h" 3
>template <class MatT, class MatB, class Side>
>inline void
>tri_solve(const MatT& T, const MatB& B, Side s)
>{
> tri_solve__(T, const_cast<MatB&>(B), s);
>}
># 2357 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix, class VecX, class VecY>
>inline void
>rank_one_update(const Matrix& A_,
> const VecX& x, const VecY& y)
>{
> Matrix& A = const_cast<Matrix&>(A_);
> ;
> ;
> typename Matrix::iterator i;
> typename Matrix::OneD::iterator j, jend;
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> *j += x[j.row()] * std::conj(y[j.column()]);
> }
>}
># 2396 "/usr/local/include/mtl/mtl.h" 3
>template <class Matrix, class VecX, class VecY>
>inline void
>rank_two_update(const Matrix& A_,
> const VecX& x, const VecY& y)
>{
> Matrix& A = const_cast<Matrix&>(A_);
> ;
> ;
> ;
> typename Matrix::iterator i;
> typename Matrix::OneD::iterator j, jend;
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> *j += x[j.row()] * std::conj(y[j.column()])
> + y[j.row()] * std::conj(x[j.column()]);
> }
>}
>
>template <class VecX, class VecY>
>inline void
>copy__(const VecX& x, VecY& y, fast::count<0>)
>{
> mtl_algo::copy(x.begin(), x.end(), y.begin());
>}
># 2431 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY>
>inline void
>oned_copy(const VecX& x, VecY& y, dense_tag, dense_tag)
>{
> ;
>
> copy__(x, y, typename dim_n<VecX>::RET());
>}
># 2465 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY>
>inline void
>oned_copy(const VecX& x, VecY& y, sparse_tag, dense_tag)
>{
> typedef typename linalg_traits<VecY>::value_type T;
> mtl::set_value(y, T(0));
> typename VecX::const_iterator xi;
> for (xi = x.begin(); xi != x.end(); ++xi)
> y[xi.index()] = *xi;
>}
># 2486 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY>
>inline void
>scatter(const VecX& x, const VecY& y_)
>{
> VecY& y = const_cast<VecY&>(y_);
> typename VecX::const_iterator xi;
> for (xi = x.begin(); xi != x.end(); ++xi)
> y[xi.index()] = *xi;
>}
># 2505 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY>
>inline void
>gather(const VecX& x, const VecY& y_)
>{
> VecY& y = const_cast<VecY&>(y_);
> typedef typename VecX::value_type T;
> typename VecY::iterator yi;
> for (yi = y.begin(); yi != y.end(); ++yi)
> *yi = x[yi.index()];
>}
>
>
>template <class VecX, class VecY, class Tag>
>inline void
>oned_copy(const VecX& x, VecY& y, Tag, sparse_tag)
>{
> ;
> y.clear();
> typename VecX::const_iterator i = x.begin(), iend = x.end();
> for (; i != iend; ++i)
> y.push_back(i.index(), *i);
>}
>
>
>template <class VecX, class VecY>
>inline void
>copy__(const VecX& x, VecY& y, oned_tag)
>{
> typedef typename linalg_traits<VecX>::sparsity SpX;
> typedef typename linalg_traits<VecY>::sparsity SpY;
> oned_copy(x, y, SpX(), SpY());
>}
>
>
>template <class MatA, class MatB>
>inline void
>twod_copy_default(const MatA& A, MatB& B)
>{
> typename MatA::const_iterator i;
> typename MatA::OneD::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> B(j.row(),j.column()) = *j;
> }
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, rectangle_tag)
>{
> twod_copy_default(A, B);
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, banded_tag)
>{
> twod_copy_default(A, B);
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, symmetric_tag)
>{
> typename MatA::const_iterator i;
> typename MatA::OneD::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j) {
> B(j.row(),j.column()) = *j;
> B(j.column(),j.row()) = *j;
> }
> }
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, triangle_tag)
>{
> typedef typename matrix_traits<MatB>::value_type T;
>
> if (A.is_unit())
> set_diagonal(B, T(1));
>
> twod_copy(A, B, rectangle_tag());
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy__(const MatA& A, MatB& B, dense_tag)
>{
> typedef typename matrix_traits<MatA>::shape Shape;
> twod_copy(A, B, Shape());
>}
># 2612 "/usr/local/include/mtl/mtl.h" 3
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, row_tag, row_tag)
>{
> B.fast_copy(A);
>}
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, column_tag, column_tag)
>{
> B.fast_copy(A);
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, row_tag, column_tag)
>{
> twod_copy__(A, B, dense_tag());
>}
>template <class MatA, class MatB>
>inline void
>twod_copy(const MatA& A, MatB& B, column_tag, row_tag)
>{
> twod_copy__(A, B, dense_tag());
>}
>
>template <class MatA, class MatB>
>inline void
>twod_copy__(const MatA& A, MatB& B, sparse_tag)
>{
> typedef typename matrix_traits<MatA>::orientation OrienA;
> typedef typename matrix_traits<MatB>::orientation OrienB;
> twod_copy(A, B, OrienA(), OrienB());
>}
>
>template <class MatA, class MatB>
>inline void
>copy__(const MatA& A, MatB& B, twod_tag)
>{
> ;
> ;
>
> typedef typename matrix_traits<MatB>::sparsity Sparsity;
> twod_copy__(A, B, Sparsity());
>}
># 2672 "/usr/local/include/mtl/mtl.h" 3
>template <class LinalgA, class LinalgB>
>inline void
>copy(const LinalgA& A, const LinalgB& B_)
>{
> LinalgB& B = const_cast<LinalgB&>(B_);
> typedef typename linalg_traits<LinalgA>::dimension Dim;
> copy__(A, B, Dim());
>}
>
>template <class VecX, class VecY> inline
>void
>add__(const VecX& x, VecY& y, fast::count<0>)
>{
> typedef typename VecX::value_type T;
> mtl_algo::transform_add(x.begin(), x.end(), y.begin());
>
>}
># 2699 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY> inline
>void
>add__(const VecX& x, VecY& y, oned_tag)
>{
> ;
>
> add__(x, y, dim_n<VecX>::RET());
>}
>
>
>template <class VecX, class VecY, class VecZ> inline
>void
>oned_add(const VecX& x, const VecY& y, VecZ& z, fast::count<0>)
>{
> typedef typename VecX::value_type T;
> mtl_algo::transform(x.begin(), x.end(), y.begin(), z.begin(), std::plus<T>());
>}
># 2726 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY, class VecZ>
>inline void
>oned_add(const VecX& x, const VecY& y, VecZ& z_, sparse_tag)
>{
>
> typedef typename VecZ::value_type T;
> compressed1D<T> z;
> typedef typename VecX::const_iterator xiter;
> typedef typename VecY::const_iterator yiter;
>
> xiter xi = x.begin();
> xiter xiend = x.end();
> yiter yi = y.begin();
> yiter yiend = y.end();
>
> while (xi != xiend && yi != yiend) {
> if (yi.index() < xi.index()) {
> z.push_back(yi.index(), *yi);
> ++yi;
> } else if (xi.index() < yi.index()) {
> z.push_back(xi.index(), *xi);
> ++xi;
> } else {
> z.push_back(xi.index(), *yi + *xi);
> ++xi; ++yi;
> }
> }
> while (xi != xiend) {
> z.push_back(xi.index(), *xi);
> ++xi;
> }
> while (yi != yiend) {
> z.push_back(yi.index(), *yi);
> ++yi;
> }
> z_.clear();
> mtl::copy(z, z_);
>}
>
>template <class VecX, class VecY, class VecZ>
>inline void
>oned_add(const VecX& x, const VecY& y, VecZ& z, dense_tag)
>{
>
> oned_add(x, y, z, typename dim_n<VecX>::RET());
>}
># 2785 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY, class VecZ>
>inline void
>add(const VecX& x, const VecY& y, const VecZ& z_)
>{
> VecZ& z = const_cast<VecZ&>(z_);
> ;
> ;
> typedef typename linalg_traits<VecZ>::sparsity Sparsity;
> oned_add(x, y, z, Sparsity());
>}
># 2808 "/usr/local/include/mtl/mtl.h" 3
>template <class VecW, class VecX, class VecY, class VecZ>
>inline void
>add(const VecX& x, const VecY& y, const VecZ& z, const VecW& w_)
> 
>{
> VecW& w = const_cast<VecW&>(w_);
> ;
> ;
> ;
>
> typename VecX::const_iterator x_i = x.begin();
> typename VecY::const_iterator y_i = y.begin();
> typename VecZ::const_iterator z_i = z.begin();
> typename VecW::iterator w_i = w.begin();
>
> while (not_at(x_i, x.end())) {
> *w_i = *x_i + *y_i + *z_i;
> ++x_i; ++y_i; ++z_i; ++w_i;
> }
>}
>
>
>template <class MatA, class MatB>
>inline void
>twod_add_default(const MatA& A, MatB& B)
>{
> typename MatA::const_iterator i;
> typename MatA::OneD::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> B(j.row(), j.column()) += *j;
> }
>}
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, banded_tag)
>{
> twod_add_default(A, B);
>}
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, rectangle_tag)
>{
> twod_add_default(A, B);
>}
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, triangle_tag)
>{
> typedef typename matrix_traits<MatA>::size_type Int;
> typedef typename matrix_traits<MatA>::value_type T;
> if (A.is_unit())
> for (Int i = 0; i < std::min(A.nrows(),A.ncols()); ++i)
> B(i,i) += T(1);
>
> twod_add(A, B, banded_tag());
>}
>
>
>
>
>template <class MatA, class MatB>
>inline void
>twod_symmetric_add(const MatA& A, MatB& B, row_tag)
>{
> typename MatA::const_iterator i;
> typename MatA::Row::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin();
> jend = (*i).end();
> if (A.is_upper()) {
> B(j.column(), j.row()) += *j;
> ++j;
> } else
> --jend;
> for (; j != jend; ++j) {
> B(j.row(), j.column()) += *j;
> B(j.column(), j.row()) += *j;
> }
> if (A.is_lower())
> B(j.column(), j.row()) += *j;
> }
>}
>
>template <class MatA, class MatB>
>inline void
>twod_symmetric_add(const MatA& A, MatB& B, column_tag)
>{
> typename MatA::const_iterator i;
> typename MatA::Column::const_iterator j, jend;
>
> for (i = A.begin(); i != A.end(); ++i) {
> j = (*i).begin();
> jend = (*i).end();
> if (A.is_lower()) {
> B(j.column(), j.row()) += *j;
> ++j;
> } else
> --jend;
> for (; j != jend; ++j) {
> B(j.row(), j.column()) += *j;
> B(j.column(), j.row()) += *j;
> }
> if (A.is_upper())
> B(j.column(), j.row()) += *j;
> }
>}
>
>
>template <class MatA, class MatB>
>inline void
>twod_add(const MatA& A, MatB& B, symmetric_tag)
>{
> typedef typename matrix_traits<MatA>::orientation Orien;
> twod_symmetric_add(A, B, Orien());
>}
>
>
>template <class MatA, class MatB>
>inline void
>add__(const MatA& A, MatB& B, twod_tag)
>{
> ;
> ;
>
> typedef typename matrix_traits<MatA>::shape Shape;
> twod_add(A, B, Shape());
>}
># 2951 "/usr/local/include/mtl/mtl.h" 3
>template <class LinalgA, class LinalgB>
>inline void
>add(const LinalgA& A, const LinalgB& B_)
>{
> LinalgB& B = const_cast<LinalgB&>(B_);
> typedef typename linalg_traits<LinalgA>::dimension Dim;
> add__(A, B, Dim());
>}
>
>
>
>template <class VecX, class VecY, class VecZ>
>inline void
>ele_mult(const VecX& x, const VecY& y, const VecZ& z_, fast::count<0>)
>{
> VecZ& z = const_cast<VecZ&>(z_);
> typedef typename VecX::value_type T;
> mtl_algo::transform(x.begin(), x.end(), y.begin(), z.begin(),
> std::multiplies<T>());
>}
># 2988 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY, class VecZ>
>inline void
>ele_mult(const VecX& x, const VecY& y, const VecZ& z_)
>{
> VecZ& z = const_cast<VecZ&>(z_);
> ;
> ;
>
>
> ele_mult(x, y, z, typename dim_n<VecX>::RET());
>}
># 3011 "/usr/local/include/mtl/mtl.h" 3
>template <class MatA, class MatB>
>inline void
>ele_mult(const MatA& A, const MatB& B_)
>{
> MatB& B = const_cast<MatB&>(B_);
>
>
>
>
>
>
> typename MatB::iterator i;
> typename MatB::OneD::iterator j, jend;
>
> for (i = B.begin(); i != B.end(); ++i) {
> j = (*i).begin(); jend = (*i).end();
> for (; j != jend; ++j)
> *j *= A(j.row(),j.column());
> }
>}
>
>
>
>
>
>
>
>template <class VecX, class VecY, class VecZ>
>inline void
>ele_div(const VecX& x, const VecY& y, const VecZ& z_)
>{
> VecZ& z = const_cast<VecZ&>(z_);
> ;
> ;
>
> typedef typename VecX::value_type T;
> mtl_algo::transform(x.begin(), x.end(), y.begin(), z.begin(),
> std::divides<T>());
>}
>
>
>
>
>template <class VecX, class VecY>
>inline void
>swap(VecX& x, VecY& y, fast::count<0>)
>{
> mtl_algo::swap_ranges(x.begin(), x.end(), y.begin());
>}
># 3069 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY>
>inline void
>swap(VecX& x, VecY& y, oned_tag)
>{
> ;
> swap(x, y, dim_n<VecX>::RET());
>}
>
>
>
>template <class MatA, class MatB>
>inline void
>swap(MatA& A, MatB& B, twod_tag)
>{
> ;
> ;
>
> typename MatA::iterator A_i;
> typename MatA::OneD::iterator A_ij, A_ijend;
> typename MatB::iterator B_i;
> typename MatB::Row::iterator B_ij;
>
> A_i = A.begin(); B_i = B.begin();
> while (A_i != A.end()) {
> A_ij = (*A_i).begin(); B_ij = (*B_i).begin();
> A_ijend = (*A_i).end();
> while (A_ij != A_ijend) {
> typename matrix_traits<MatA>::value_type tmp = *B_ij;
> *B_ij = *A_ij;
> *A_ij = tmp;
> ++A_ij; ++B_ij;
> }
> ++A_i; ++B_i;
> }
>}
># 3118 "/usr/local/include/mtl/mtl.h" 3
>template <class LinalgA, class LinalgB>
>inline void
>swap(const LinalgA& A, const LinalgB& B)
>{
> typedef typename linalg_traits<LinalgA>::dimension Dim;
> swap(const_cast<LinalgA&>(A), const_cast<LinalgB&>(B), Dim());
>}
>
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, fast::count<0>)
>{
> return mtl_algo::inner_product(x.begin(), x.end(), y.begin(), s);
>}
># 3143 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, dense_tag, dense_tag)
>{
> return dot(x, y, s, dim_n<VecX>::RET());
>}
>
>template <class InputIterator1, class InputIterator2, class T>
>inline T
>sparse_inner_product(InputIterator1 f1, InputIterator1 l1,
> InputIterator2 f2, InputIterator2 l2, T init)
>{
> InputIterator1 first1 = f1;
> InputIterator1 last1 = l1;
> InputIterator2 first2 = f2;
> InputIterator2 last2 = l2;
>
> while (first1 != last1 && first2 != last2) {
> if (first1.index() == first2.index())
> init += (*first1++ * *first2++);
> else if (first1.index() < first2.index())
> ++first1;
> else
> ++first2;
> }
> return init;
>}
>
>template <class IndexedIterator, class RandomAccessIterator, class T>
>inline T
>sparse_dense_inner_product(IndexedIterator f1, IndexedIterator l1,
> RandomAccessIterator f2, T init)
>{
> IndexedIterator first1 = f1, last1 = l1;
> RandomAccessIterator first2 = f2;
>
> while (first1 != last1) {
> init += (*first1 * first2[first1.index()]);
> ++first1;
> }
> return init;
>}
>
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, sparse_tag, sparse_tag)
>{
> if (x.nnz() < y.nnz())
> return sparse_inner_product(x.begin(), x.end(), y.begin(), y.end(), s);
> else
> return sparse_inner_product(y.begin(), y.end(), x.begin(), x.end(), s);
>}
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, dense_tag, sparse_tag)
>{
> return sparse_dense_inner_product(y.begin(), y.end(), x.begin(), s);
>}
>
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s, sparse_tag, dense_tag)
>{
> return sparse_dense_inner_product(x.begin(), x.end(), y.begin(), s);
>}
># 3218 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY, class T>
>inline T
>dot(const VecX& x, const VecY& y, T s)
>{
> ;
> typedef typename linalg_traits<VecX>::sparsity SparseX;
> typedef typename linalg_traits<VecY>::sparsity SparseY;
> return dot(x, y, s, SparseX(), SparseY());
>}
># 3235 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY>
>inline typename VecX::value_type
>dot(const VecX& x, const VecY& y)
>{
> typedef typename VecX::value_type T;
> return mtl::dot(x, y, T(0));
>}
># 3263 "/usr/local/include/mtl/mtl.h" 3
>template <class T>
>struct conj_func {
> typedef T result_type;
> inline T operator()(const T& x) const { return std::conj(x); }
>};
>
>template <class VecX, class VecY, class T>
>inline T
>dot_conj(const VecX& x, const VecY& y, T s, fast::count<0>)
>{
> return mtl_algo::inner_product(x.begin(), x.end(),
> trans_iter(y.begin(), conj_func<T>()), s);
>}
># 3294 "/usr/local/include/mtl/mtl.h" 3
>template <class VecX, class VecY, class T>
>inline T
>dot_conj(const VecX& x, const VecY& y, T s)
>{
> ;
> return dot_conj(x, y, s, dim_n<VecX>::RET());
>}
>
>
>
>
>
>
>
>template <class VecX, class VecY>
>inline typename VecX::value_type
>dot_conj(const VecX& x, const VecY& y)
>{
> typedef typename VecX::value_type T;
> return mtl::dot_conj(x, y, T(0));
>}
>
>
>
>
>
>
>}
># 22 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrMatrix.h" 2
>
>namespace FMR {
>
> namespace Numerics {
>
>
> typedef mtl::matrix<double, mtl::rectangle<>, mtl::dense<>, mtl::row_major>::type Matrix;
>
> typedef mtl::matrix<double, mtl::triangle<mtl::lower>, mtl::packed<>, mtl::row_major>::type TriangleMatrix;
>
> typedef mtl::matrix<double, mtl::symmetric<mtl::lower>, mtl::packed<>, mtl::row_major>::type SymmetricMatrix;
>
> typedef mtl::matrix<double, mtl::diagonal<>, mtl::banded<>, mtl::column_major>::type BandedMatrix;
>
> typedef mtl::dense1D<double> Vector;
>
> }
>
>}
>
>
>
>
>
>namespace FMR {
>
> namespace Numerics {
>
>
>
>
>
>
>
> err_t DimensionalReduction(const SymmetricMatrix& in, size_t dim_input,double thres_input,Matrix& out,size_t& dim);
>
>
>
>
>
> err_t CholeskyDecomposition(const SymmetricMatrix& in,TriangleMatrix& out);
>
>
>
>
>
> err_t Square(const Matrix& in,SymmetricMatrix& out);
>
>
>
>
>
> err_t OrthogonalTransform(const SymmetricMatrix& in,const Matrix& trans,SymmetricMatrix& out);
>
>
>
>
>
> err_t TridiagonalDecomposition(const SymmetricMatrix& in,SymmetricMatrix& out,Matrix& trans);
># 89 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrMatrix.h"
> err_t TridiagonalEigenvalues(const SymmetricMatrix& in,SymmetricMatrix& out,Matrix& evec);
>
>
>
>
>
>
> err_t Eigenvalues(const SymmetricMatrix& in,SymmetricMatrix& out,Matrix& evec);
>
>
>
>
> err_t SortEigenvalues(SymmetricMatrix& eval,Matrix& evec);
>
>
>
>
> err_t FillByInterpolate(Matrix& matrix);
>
> }
>
>}
># 8 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/option/fmrBasketPricer.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrRanGen.h" 1
># 13 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrRanGen.h"
>namespace FMR {
>
> namespace Numerics {
>
> namespace GeneratorPolicies {
>
> template <typename Gen>
> class Scalar
> {
> public:
> Scalar(void) {}
> virtual ~Scalar() {}
>
> typedef Gen Generator;
>
> template <typename Sample>
> static void next(Generator& gen,Sample& sample)
> {
> for (typename Sample::iterator p=sample.begin(), e=sample.end();p!=e;++p)
> {
> *p = gen();
> }
> }
>
> double operator()(void);
> };
>
> template <typename Gen>
> class Vector
> {
> public:
> Vector(void) {}
> virtual ~Vector() {}
>
> typedef Gen Generator;
>
> template <typename Sample>
> static void next(Generator& gen,Sample& sample)
> {
> gen(sample);
> }
>
> template <typename Sample>
> void operator()(Sample& z);
> };
>
> }
>
> namespace Generators {
>
> template <typename Policy>
> class Generator
> {
> public:
> Generator(void) {}
> virtual ~Generator() {}
>
> template <typename Sample>
> void next(Sample& sample)
> {
> Policy::next(*static_cast<typename Policy::Generator*>(this),sample);
> }
> };
>
> class Rand : public Generator<GeneratorPolicies::Scalar<Rand> >
> {
> public:
> Rand(size_t dimension,long seed) {srand(seed);}
> virtual ~Rand() {}
>
> double operator()(void) {return (double)rand()/(double)2147483647;}
> };
>
> class Lecuyer : public Generator<GeneratorPolicies::Scalar<Lecuyer> >
> {
> public:
> Lecuyer(size_t dimension,long seed);
> virtual ~Lecuyer() {}
>
>
> double operator()(void);
>
> private:
>
> static const long m1;
> static const long a1;
> static const long q1;
> static const long r1;
> static const long m2;
> static const long a2;
> static const long q2;
> static const long r2;
> static const short bufferSize;
> static const long bufferNormalizer;
> static const double maxRandom;
>
> long temp1, temp2;
> long y;
> std::vector<long> buffer;
> };
>
> class Gfsr : public Generator<GeneratorPolicies::Scalar<Gfsr> >
> {
> public:
>
> Gfsr(size_t dimension,long seed);
> virtual ~Gfsr() {}
>
> double operator()(void);
>
> private:
>
> long seeds[250];
> int p, q;
>
> static const long two24 ;
> static const double twom24;
> };
>
> class Ranlux : public Generator<GeneratorPolicies::Scalar<Ranlux> >
> {
> public:
>
> Ranlux(size_t dimension,long seed);
> virtual ~Ranlux() {}
>
> double operator()(void);
>
> private:
>
> static const unsigned short level[5];
> static const unsigned long mask_lo;
> static const unsigned long mask_hi;
> static const long two24;
> static const double twom24;
>
> unsigned short i;
> unsigned short j;
> unsigned short n;
> unsigned long u[24];
> unsigned short skip;
> unsigned short carry;
>
> unsigned long increment_state(void);
> };
>
> class Sobol : public Generator<GeneratorPolicies::Vector<Sobol> >
> {
> public:
>
> Sobol(size_t dimension,long seed);
> virtual ~Sobol(void) {blank();}
>
> Sobol& operator=(const Sobol& that)
> {
> if (&that!=this) {blank();copy(that);}
> return *this;
> }
>
> template <typename Sample>
> void operator()(Sample& z)
> {
> if (too_big)
> {
>
> for (typename Sample::iterator p=z.begin(),e=z.end();p!=e;++p)
> *p = (typename Sample::value_type)(auxgen());
> return;
> }
>
> short i, j, k;
> unsigned long im = index++;
>
>
> for (j=0;j<maxbit;++j,im>>=1)
> {
> if ((im&1L)==0) break;
> }
>
> i = j * maxdim;
>
> typename Sample::iterator iter = z.begin();
> for (k=0;k<dim;++k,++iter)
> {
> ix[k] ^= iv[i + k];
> *iter = (typename Sample::value_type)(factor*(double)ix[k]);
> }
> }
>
> private:
>
> void blank(void)
> {
> if (!too_big)
> {
> if (iv) free(iv);
> if (ix) free(ix);
> }
> }
>
> void copy(const Sobol& that)
> {
> size_t i = 0;
> iv = (unsigned long*) calloc(maxbit*maxdim, sizeof(unsigned long));
> for (i=0; i<maxbit*maxdim; i++) iv[i]=that.iv[i];
> dim = that.dim;
> ix = (unsigned long*) calloc(dim, sizeof(unsigned long));
> for (i=0; i<dim; i++) ix[i]=that.ix[i];
> index = that.index;
> factor = that.factor;
> coordinate = that.coordinate;
> called = that.called;
> too_big = that.too_big;
> auxgen = that.auxgen;
> }
>
> static const short ip[];
> static const short mdeg[];
> static const short maxdim;
> static const short maxbit;
>
> unsigned long *ix;
> unsigned long index;
>
> size_t dim;
> double factor;
> unsigned short coordinate;
> unsigned short called;
> unsigned long *iv;
>
> bool too_big;
> Gfsr auxgen;
>
> short get_index(short k,short j) const {return k+(j-1)*maxdim;}
> };
>
> }
>
> namespace Measures {
>
> class InverseCumulativeNormal
> {
> public:
> InverseCumulativeNormal(void) {}
> virtual ~InverseCumulativeNormal() {}
>
>
>
>
>
>
> double operator()(double u) const
> {
> if (u<1.e-30) return 0.0;
> if (u>1-1.e-30) return 0.0;
>
>
> const double
> a1 = -3.969683028665376e+01,
> a2 = 2.209460984245205e+02,
> a3 = -2.759285104469687e+02,
> a4 = 1.383577518672690e+02,
> a5 = -3.066479806614716e+01,
> a6 = 2.506628277459239e+00;
>
> const double
> b1 = -5.447609879822406e+01,
> b2 = 1.615858368580409e+02,
> b3 = -1.556989798598866e+02,
> b4 = 6.680131188771972e+01,
> b5 = -1.328068155288572e+01;
>
> const double
> c1 = -7.784894002430293e-03,
> c2 = -3.223964580411365e-01,
> c3 = -2.400758277161838e+00,
> c4 = -2.549732539343734e+00,
> c5 = 4.374664141464968e+00,
> c6 = 2.938163982698783e+00;
>
> const double
> d1 = 7.784695709041462e-03,
> d2 = 3.224671290700398e-01,
> d3 = 2.445134137142996e+00,
> d4 = 3.754408661907416e+00;
>
>
> const double
> u_low = 0.02425,
> u_high = 1.0 - u_low;
>
> register double z, r;
>
>
> if ( u < u_low )
> {
> z = sqrt(-2.0*log(u));
> z = (((((c1*z+c2)*z+c3)*z+c4)*z+c5)*z+c6) / ((((d1*z+d2)*z+d3)*z+d4)*z+1.0);
> }
>
> else if ( u <= u_high )
> {
> z = u - 0.5;
> r = z*z;
> z = (((((a1*r+a2)*r+a3)*r+a4)*r+a5)*r+a6)*z / (((((b1*r+b2)*r+b3)*r+b4)*r+b5)*r+1.0);
> }
>
> else
> {
> z = sqrt(-2.0*log(1.0-u));
> z = -(((((c1*z+c2)*z+c3)*z+c4)*z+c5)*z+c6) / ((((d1*z+d2)*z+d3)*z+d4)*z+1.0);
> }
>
> return z;
> }
>
> };
>
> class Identity
> {
> public:
> Identity(void) {}
> virtual ~Identity() {}
>
> double operator()(double u) const {return u;}
> };
>
> }
>
> namespace RandomPools {
>
> class Empty
> {
> public:
> Empty(size_t dimension) {}
> virtual ~Empty() {}
>
> bool empty(void) const {return true;}
>
> template <typename Sample>
> void pop(Sample& sample) {}
>
> template <typename Sample>
> void push(const Sample& sample) {}
> };
>
> class Antithetic
> {
> public:
>
> Antithetic(size_t dimension) : dim(dimension) {init(dim);}
> Antithetic(const Antithetic& that) {init(that.dim);}
> Antithetic& operator=(const Antithetic& that) {if (this!=&that) {blank(); init(that.dim);} return *this;}
> virtual ~Antithetic(void) {blank();}
>
> bool empty(void) const {return is_empty;}
>
> template <typename Sample>
> void pop(Sample& sample)
> {
> std::copy(store,end,sample.begin());
> is_empty = true;
> }
>
> template <typename Sample>
> void push(const Sample& sample)
> {
> std::transform(sample.begin(),sample.end(),store,std::negate<double>());
> is_empty = false;
> }
>
> private:
>
> void blank(void) {delete[] store;}
> void init(size_t dimension) {is_empty=true; store=new double[dimension]; end=&store[dimension];}
> bool is_empty;
> size_t dim;
> double* store;
> double* end;
> };
>
> }
>
>
> template
> <
> typename Engine,
> typename Measure,
> typename Pool = RandomPools::Empty
> >
> class RandomGenerator
> {
> public:
>
>
> RandomGenerator(size_t dimension,long seed=314159265)
> : dim(dimension), engine(dimension,seed), pool(dimension) {}
>
>
> RandomGenerator(Pool& ext_pool,size_t dimension,long seed=314159265)
> : dim(dimension), engine(dimension,seed), pool(ext_pool) {}
>
>
> RandomGenerator& operator=(const RandomGenerator& that)
> {
> if (&that!=this) {copy(that);}
> return *this;
> }
>
> virtual ~RandomGenerator() {}
>
>
> size_t getDimension() {return dim;}
>
>
> template <typename Sample>
> bool next(Sample& sample)
> {
> if(dim!=sample.size()) return false;
> if (!pool.empty()) {pool.pop(sample); return true;}
> engine.next(sample);
> std::transform(sample.begin(),sample.end(),sample.begin(),Measure());
> pool.push(sample);
> return true;
> }
>
> private:
>
> void copy(const RandomGenerator& that)
> {
> dim = that.dim;
> engine.operator=((that.engine));
> pool.operator=((that.pool));
> }
>
> size_t dim;
> Engine engine;
> Pool pool;
> };
>
> }
>
>}
>
>
>
>inline double FMR::Numerics::Generators::Gfsr::operator()(void)
>{
> p--; if (p<0) p=249;
> q--; if (q<0) q=249;
>
> seeds[p] = seeds[q] ^ seeds[p];
> return twom24*seeds[p];
>}
>
>
>
>
>inline unsigned long FMR::Numerics::Generators::Ranlux::increment_state(void)
>{
> long delta = u[j] - u[i] - carry;
>
> if (delta & mask_hi)
> {
> carry = 1;
> delta &= mask_lo;
> }
> else carry = 0;
>
> u[i] = delta;
>
> if (i==0) i=23;
> else --i;
> if (j==0) j=23;
> else --j;
>
> return delta;
>}
>
>inline double FMR::Numerics::Generators::Ranlux::operator()(void)
>{
> unsigned long r = increment_state();
>
> ++n;
>
> if (n==24)
> {
> n = 0;
> for (unsigned short l=0;l<skip;++l) increment_state();
> }
>
> return r * twom24;
>}
># 9 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/option/fmrBasketPricer.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace Visitors {
>
> class Montecarlo : public InstrSpecs::Visitor
> {
> public:
> long trd,settl;
> RunTimeAlgo* payoff;
> const InstrSpecs::Entry* entry;
> std::string underlying;
> std::string prefix;
>
> FMR::Numerics::Vector& basket;
> FMR::Numerics::Vector& growth_rate;
> FMR::Numerics::Vector& volatility_vect;
> FMR::Numerics::SymmetricMatrix correlation_matrix;
>
> Service::ProxyType* pxreport;
> Service::ProxyType* pxcurve;
> Service::ProxyType* pxvarg;
>
> Montecarlo (long trade,
> long settlement,
> FMR::Numerics::Vector& asset_basket,
> FMR::Numerics::Vector& gr_rate,
> FMR::Numerics::Vector& vol_vect,
> FMR::Numerics::SymmetricMatrix cor_mat,
> RunTimeAlgo* rtalgo,
> Service::ProxyType* report,
> const std::string& underlying_name,
> const std::string& prefix_name,
> const InstrSpecs::Entry* instr_entry,
> Service::ProxyType* curve,
> Service::ProxyType* varg);
> virtual ~Montecarlo() {}
>
> virtual err_t connect(const Instrument* instrument);
> virtual err_t disconnect(const Instrument* instrument);
> virtual err_t calculate(const Instrument* instrument);
> };
>
> }
>
> namespace Private {
>
> typedef FMR::Numerics::RandomGenerator
> <
> FMR::Numerics::Generators::Ranlux,
> FMR::Numerics::Measures::Identity
> >
> Uniform;
>
> typedef FMR::Numerics::RandomGenerator
> <
> FMR::Numerics::Generators::Ranlux,
> FMR::Numerics::Measures::InverseCumulativeNormal
> >
> PseudoNormal;
>
> typedef FMR::Numerics::RandomGenerator
> <
> FMR::Numerics::Generators::Sobol,
> FMR::Numerics::Measures::InverseCumulativeNormal
> >
> QuasiNormal;
>
> }
>
> }
>
>}
># 2 "fmrBasketPricer.c" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrOptPayoff.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtAlgo.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrOptPayoff.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrVisitor.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrMarket.h" 1
>
>
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrTimeArray.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrArray.h" 1
># 12 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrArray.h"
>namespace FMR {
>
> namespace Platform {
>
> namespace ArrayTraits {
>
> template
> <
> typename T
> >
> class ArrayOfPointers
> {
> public:
> ArrayOfPointers(void) {}
> virtual ~ArrayOfPointers() {}
>
>
>
>
> typedef T ValueType;
>
> typedef T* Entry;
>
> typedef T* Pointer;
>
> typedef const T* ConstPointer;
>
> typedef T& Reference;
>
> typedef const T& ConstReference;
>
> typedef Entry* Iterator;
>
> typedef const Entry* ConstIterator;
>
> typedef std::vector<Entry> Store;
>
>
>
>
>
> Reference get_reference(Entry& entry) const {return *entry;}
>
> ConstReference get_reference(const Entry& entry) const {return *entry;}
>
> Pointer get_pointer(Entry& entry) const {return entry;}
>
> ConstPointer get_pointer(const Entry& entry) const {return entry;}
>
> Entry& get_entry(Pointer& ptr) const {return ptr;}
>
>
>
>
>
> void destroy(Iterator start,Iterator end);
>
> void clone(ConstIterator start,ConstIterator end,Store& store);
>
> private:
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> LockModel mx_destroy;
> };
>
>
> template
> <
> typename T
> >
> class ArrayOfObjects
> {
> public:
> ArrayOfObjects(void) {}
> virtual ~ArrayOfObjects() {}
>
>
>
>
> typedef T ValueType;
>
> typedef T Entry;
>
> typedef T* Pointer;
>
> typedef const T* ConstPointer;
>
> typedef T& Reference;
>
> typedef const T& ConstReference;
>
> typedef Entry* Iterator;
>
> typedef const Entry* ConstIterator;
>
> typedef std::vector<Entry> Store;
>
>
>
>
>
> Reference get_reference(Entry& entry) const {return entry;}
>
> ConstReference get_reference(const Entry& entry) const {return entry;}
>
> Pointer get_pointer(Entry& entry) const {return &entry;}
>
> ConstPointer get_pointer(const Entry& entry) const {return &entry;}
>
> Entry& get_entry(Pointer& ptr) const {return *ptr;}
>
>
>
>
>
> void destroy(Iterator start,Iterator end) {}
>
> void clone(ConstIterator start,ConstIterator end,Store& store);
>
> };
>
> }
>
>
> template
> <
> typename ArrayTrait
> >
> class Array : private ArrayTrait
> {
> public:
>
>
>
> typedef typename ArrayTrait::ValueType ValueType;
>
> typedef typename ArrayTrait::Entry Entry;
>
> typedef typename ArrayTrait::Pointer Pointer;
>
> typedef typename ArrayTrait::ConstPointer ConstPointer;
>
> typedef typename ArrayTrait::Reference Reference;
>
> typedef typename ArrayTrait::ConstReference ConstReference;
>
> typedef typename ArrayTrait::Iterator Iterator;
>
> typedef typename ArrayTrait::ConstIterator ConstIterator;
>
> typedef typename ArrayTrait::Store Store;
>
>
>
>
>
> typedef Entry value_type;
>
> typedef value_type* pointer;
>
> typedef const value_type* const_pointer;
>
> typedef value_type& reference;
>
> typedef const value_type& const_reference;
>
> typedef value_type* iterator;
>
> typedef const value_type* const_iterator;
>
> typedef typename Store::size_type size_type;
>
> typedef typename Store::difference_type difference_type;
>
>
>
>
>
> Array(void) {}
>
> Array(size_t reserve_size) {store.reserve(reserve_size);}
>
> Array(const Array& that) {copy(that);}
>
> Array& operator=(const Array& that)
> {
> if (&that!=this)
> {
> blank();
> copy(that);
> }
> return *this;
> }
>
> virtual ~Array() {blank();}
>
>
>
>
>
> bool empty(void) const {return store.empty();}
>
> size_t size(void) const {return store.size();}
>
> void clear(void) {blank();}
>
> void revert(void) {std::reverse(store.begin(),store.end());}
>
> void append(Array& that);
>
> void push_back(Pointer ptr) {store.push_back(ArrayTrait::get_entry(ptr));}
>
>
>
>
>
> Iterator begin(void) {return store.begin().base();}
>
> ConstIterator begin(void) const {return store.begin().base();}
>
> Iterator end(void) {return store.end().base();}
>
> ConstIterator end(void) const {return store.end().base();}
>
> Reference front(void) {return ArrayTrait::get_reference(store.front());}
>
> ConstReference front(void) const {return ArrayTrait::get_reference(store.front());}
>
> Reference back(void) {return ArrayTrait::get_reference(store.back());}
>
> ConstReference back(void) const {return ArrayTrait::get_reference(store.back());}
>
>
> private:
> Store store;
> void blank(void);
> void copy(const Array& that);
> };
>
>
> template
> <
> typename TimeTrait,
> typename ArrayTrait
> >
> class TimeArray : public Array<ArrayTrait>, private TimeTrait
> {
> public:
>
>
>
> typedef typename Array<ArrayTrait>::ValueType ValueType;
>
> typedef typename Array<ArrayTrait>::Entry Entry;
>
> typedef typename Array<ArrayTrait>::Pointer Pointer;
>
> typedef typename Array<ArrayTrait>::ConstPointer ConstPointer;
>
> typedef typename Array<ArrayTrait>::Reference Reference;
>
> typedef typename Array<ArrayTrait>::ConstReference ConstReference;
>
> typedef typename Array<ArrayTrait>::Iterator Iterator;
>
> typedef typename Array<ArrayTrait>::ConstIterator ConstIterator;
>
> typedef typename Array<ArrayTrait>::Store Store;
>
>
>
>
>
> typedef Entry value_type;
>
> typedef value_type* pointer;
>
> typedef const value_type* const_pointer;
>
> typedef value_type& reference;
>
> typedef const value_type& const_reference;
>
> typedef value_type* iterator;
>
> typedef const value_type* const_iterator;
>
> typedef typename Store::size_type size_type;
>
> typedef typename Store::difference_type difference_type;
>
>
>
>
>
> typedef typename TimeTrait::Time Time;
>
>
>
>
>
> TimeArray(void) : Array<ArrayTrait>() {}
>
> TimeArray(size_t reserve_size) : Array<ArrayTrait>(reserve_size) {}
>
> TimeArray(const TimeArray& that) : Array<ArrayTrait>(that) {}
>
> TimeArray& operator=(const TimeArray& that)
> {
> Array<ArrayTrait>::operator=(that);
> return *this;
> }
>
> virtual ~TimeArray() {}
>
>
>
>
>
> void sort(void);
>
>
>
>
>
> ConstIterator synchro_after(const Time& time) const;
>
> ConstIterator synchro_at(const Time& time) const;
>
> };
>
> }
>
>}
>
>
>template <typename T>
>inline void FMR::Platform::ArrayTraits::ArrayOfPointers<T>::destroy(Iterator start,Iterator end)
>{
> FMR::Platform::Lock<LockModel> lock(mx_destroy);
> Iterator p = start;
> for (;p!=end;++p)
> {
> if(*p) delete *p;
> *p=__null;
> }
>}
>
>
>template <typename T>
>inline void FMR::Platform::ArrayTraits::ArrayOfPointers<T>::clone(ConstIterator start,ConstIterator end,Store& store)
>{
> FMR::Platform::Lock<LockModel> lock(mx_destroy);
> ConstIterator p = start;
> for(;p!=end;++p)
> {
> store.push_back(static_cast<T*>((*p)->duplicate()));
> }
>}
>
>
>template <typename T>
>inline void FMR::Platform::ArrayTraits::ArrayOfObjects<T>::clone(ConstIterator start,ConstIterator end,Store& store)
>{
> ConstIterator p = start;
> for (;p!=end;++p)
> {
> store.push_back(*p);
> }
>}
>
>
>template <typename Tr>
>void FMR::Platform::Array<Tr>::blank(void)
>{
> Tr::destroy(store.begin().base(),store.end().base());
> store.clear();
>}
>
>
>template <typename Tr>
>inline void FMR::Platform::Array<Tr>::copy(const Array& that)
>{
> size_t size = that.size();
> store.reserve(size);
> Tr::clone(that.begin(),that.end(),store);
>}
>
>
>template <typename Tr>
>inline void FMR::Platform::Array<Tr>::append(Array& that)
>{
> ConstIterator p = that.begin();
> ConstIterator e = that.end();
> for (;p!=e;++p)
> {
> store.push_back(*p);
> }
> that.store.clear();
>}
>
>
>template <typename TmTr,typename ArTr>
>void FMR::Platform::TimeArray<TmTr,ArTr>::sort(void)
>{
> typedef typename TmTr::Compare Compare;
> std::sort(this->begin(),this->end(),Compare());
>}
>
>
>template <typename TmTr,typename ArTr>
>typename FMR::Platform::TimeArray<TmTr,ArTr>::ConstIterator
>FMR::Platform::TimeArray<TmTr,ArTr>::synchro_after(const Time& time) const
>{
> ConstIterator p = this->begin();
> ConstIterator e = this->end();
> for(;p!=e;++p)
> {
> if(time<TmTr::get_time(*p))
> {
> return p;
> }
> }
> return e;
>}
>
>
>template <typename TmTr,typename ArTr>
>typename FMR::Platform::TimeArray<TmTr,ArTr>::ConstIterator
>FMR::Platform::TimeArray<TmTr,ArTr>::synchro_at(const Time& time) const
>{
> ConstIterator p = this->begin();
> ConstIterator e = this->end();
> for (;p!=e;++p)
> {
> if(!(TmTr::get_time(*p)<time))
> {
> return p;
> }
> }
> return e;
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrTimeArray.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> template <typename Type,typename TimePolicy>
> class TimeArray : public FMR::Platform::TimeArray<TimePolicy,FMR::Platform::ArrayTraits::ArrayOfPointers<Type> >
> {
> public:
>
> typedef FMR::Platform::TimeArray<TimePolicy,FMR::Platform::ArrayTraits::ArrayOfPointers<Type> > TimeArrayImpl;
>
>
>
>
> TimeArray(void) : TimeArrayImpl()
> {
> FMR::Platform::Lock<LockModel> lock(mx_ta);
> }
>
> TimeArray(size_t reserve_size) : TimeArrayImpl(reserve_size)
> {
> FMR::Platform::Lock<LockModel> lock(mx_ta);
> }
>
> TimeArray& operator=(const TimeArray& that)
> {
> FMR::Platform::Lock<LockModel> lock_s(that.mx_ta);
> FMR::Platform::Lock<LockModel> lock(mx_ta);
> TimeArrayImpl::operator=(that);
> return *this;
> }
>
> TimeArray(const TimeArray& that) : TimeArrayImpl(that)
> {
> FMR::Platform::Lock<LockModel> lock_s(that.mx_ta);
> FMR::Platform::Lock<LockModel> lock(mx_ta);
> }
>
> virtual ~TimeArray()
> {
> FMR::Platform::Lock<LockModel> lock(mx_ta);
> }
>
> private:
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_ta;
> };
>
> }
>
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrMarket.h" 2
>
>
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace MarketSpecs {
>
> class Entry : public Service::Product
> {
> public:
>
>
>
> Entry& operator=(const Entry& that);
>
> virtual ~Entry();
>
>
>
>
>
> virtual Service::Product* clone(void) const =0;
>
> virtual Service::Product* duplicate(void) const =0;
>
> virtual err_t validate(void) =0;
>
> long expiry(void) const;
>
> void set_expiry(long expiry_date);
>
>
> typedef FMR::Platform::Box<MarketSpecs::Entry> MarketOpt;
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& build_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> protected:
>
> Entry(const std::string& type);
>
> virtual void assign(const Entry& that) =0;
>
> private:
>
> long time;
> };
>
> class TimePolicy
> {
> public:
> TimePolicy(void);
> virtual ~TimePolicy();
>
> class Compare
> {
> public:
> Compare(void);
> virtual ~Compare();
> bool operator()(MarketSpecs::Entry* const& a,MarketSpecs::Entry* const& b) const;
> };
>
> typedef long Time;
> Time get_time(MarketSpecs::Entry*& entry) const;
> const Time get_time(MarketSpecs::Entry* const& entry) const;
> };
>
> typedef TimeArray<MarketSpecs::Entry,TimePolicy> ArrayImpl;
>
> class MarketImpl
> {
> public:
> MarketImpl(void);
> virtual ~MarketImpl();
> ArrayImpl array;
> };
>
> }
>
>
> typedef MarketSpecs::Entry::MarketOpt MarketOpt;
>
> template <typename T>
> class market_cast
> {
> public:
> market_cast(const MarketSpecs::Entry* ptr) : p(ptr) {}
> virtual ~market_cast() {}
> operator T (void) const {return static_cast<T>(const_cast<MarketSpecs::Entry*>(p));}
> const MarketSpecs::Entry* p;
> };
>
>
> class Market : public Service::Product
> {
> public:
>
>
>
> Market(void);
>
> Market(const Market& that);
>
> Market& operator=(const Market& that);
>
> virtual ~Market();
>
>
>
>
>
> size_t size(void);
>
> const std::string& query_market(void) const;
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> err_t insert(const MarketSpecs::Entry* entry);
>
> const MarketSpecs::Entry* synchro(long expiry_date) const;
>
> long next_expiry(long date=0) const;
>
>
> private:
> MarketSpecs::MarketImpl* impl;
>
> void blank(void);
> void copy(const Market& that);
> };
>
> }
>
>}
># 6 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBuildAlgo.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrBuildData.h" 1
>
>
>
>
>
>
>namespace FMR4000 {
>
> namespace Service {
>
> class BuildData : public Product
> {
> public:
>
> bool is_std;
>
> std::string std_name;
>
> std::string standard;
>
> void* data;
>
> void* extra;
>
>
>
>
> BuildData(void);
>
> BuildData(const BuildData& that);
>
> BuildData& operator=(const BuildData& that);
>
> virtual ~BuildData();
>
>
>
>
>
> virtual Product* clone(void) const;
>
> virtual Product* duplicate(void) const;
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
> private:
> void copy(const BuildData& that);
> };
>
> }
>
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBuildAlgo.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrProduct.h" 1
># 6 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBuildAlgo.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrLeg.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrFlavor.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrTypes.h" 1
>
>
>
>
>
>
>
>typedef unsigned short legenda_t;
>
>
>typedef unsigned long tenor_t;
>
>
>typedef unsigned short lag_t;
>
>
>typedef unsigned long bit_t;
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrFlavor.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
>
> namespace Flavors {
>
> const bit_t NoFlavor = 0x0000;
> const bit_t AccrualStart = 0x0001;
> const bit_t AccrualEnd = 0x0002;
> const bit_t Interest = 0x0004;
> const bit_t Redemption = 0x0008;
> const bit_t Payoff = Interest | Redemption;
> const bit_t RunTime = 0x0010;
> const bit_t OptCall = 0x0020;
> const bit_t OptPut = 0x0040;
> const bit_t OptStraddle = OptCall | OptPut;
> const bit_t Option = OptCall | OptPut;
> const bit_t Observation = 0x0080;
> const bit_t Callable = 0x0100;
> const bit_t Dividend = 0x0200;
> const bit_t AllFlavors = 0xffff;
>
>
> const bit_t Bond = 0x0001;
> const bit_t Floater = 0x0002;
> const bit_t Opt = 0x0004;
> const bit_t Pointer = 0x0008;
> const bit_t Main = 0x0010;
> const bit_t EquityActive = 0x0020;
> const bit_t EquityCash = 0x0040;
> const bit_t Index = 0x0080;
> const bit_t EquityBest = 0x0100;
> const bit_t EquityWorst = 0x0200;
> const bit_t EquityGeneric = EquityActive | EquityCash | EquityBest | EquityWorst;
>
> }
>
> }
>
>}
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrLeg.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrCache.h" 1
># 10 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrCache.h"
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace CacheSpecs {
>
> typedef std::vector<std::string> Index;
>
> class CacheImpl
> {
> public:
> CacheImpl(void);
> virtual ~CacheImpl();
> Index index;
> };
>
> }
>
>
> class Cache
> {
> public:
>
> enum {NPos = 0xff};
>
>
>
>
> Cache(void);
>
> Cache(const Cache& that);
>
> Cache& operator=(const Cache& that);
>
> virtual ~Cache();
>
>
>
>
>
> bool empty(void) const;
>
> size_t size(void) const;
>
> size_t find(const std::string& name) const;
>
> const std::string* name(size_t pos) const;
>
> const double* get(size_t pos,const double* cache) const;
>
> double* get(size_t pos,double* cache);
>
> err_t add(const std::string& name,size_t& pos,bool& is_added);
>
> void clear(void);
>
>
> private:
> CacheSpecs::CacheImpl* impl;
>
> void blank(void);
> void copy(const Cache& that);
> };
>
> }
>
>}
># 6 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrLeg.h" 2
>
>
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace LegSpecs {
>
> typedef std::vector<double> CacheStore;
>
> class Entry
> {
> public:
>
>
>
> long time;
>
> bit_t flavor;
>
> CacheStore cache;
>
> const Entry* link;
>
>
>
>
>
> Entry(void);
>
> Entry(const Entry& that);
>
> Entry& operator=(const Entry& that);
>
> virtual ~Entry();
>
>
>
>
> bool operator>= (const Entry& c) const;
> bool operator<= (const Entry& c) const;
> bool operator> (const Entry& c) const;
> bool operator< (const Entry& c) const;
> bool operator== (const Entry& c) const;
> bool operator!= (const Entry& c) const;
>
>
>
>
>
> Entry* clone(void);
>
> Entry* duplicate(void);
>
> err_t check(long old_time,size_t old_height);
>
> void copy(const Entry& that);
>
>
>
>
>
> long get_time(size_t offset_pos) const;
>
> err_t get_payoff(size_t offset_pos,const RtAlgo& rtalgo,double& rval) const;
>
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_legentry;
> };
>
>
> class TimePolicy
> {
> public:
>
>
>
> typedef long Time;
>
> class Compare
> {
> public:
> Compare(void);
> virtual ~Compare();
> bool operator()(Entry* const& a,Entry* const& b) const;
> };
>
>
>
>
>
> Time& get_time(Entry*& entry) const;
>
> const Time& get_time(Entry* const& entry) const;
>
> private:
> typedef FMR::Platform::OnOffLocker<> LockModel;
> };
>
> typedef TimeArray<LegSpecs::Entry,LegSpecs::TimePolicy> LegImpl;
>
> }
>
>
> class Leg : public LegSpecs::LegImpl, public Service::Product
> {
> public:
>
>
>
>
> typedef LegSpecs::LegImpl LegImpl;
>
> typedef LegImpl::ValueType ValueType;
>
> typedef LegImpl::Entry Entry;
>
> typedef LegImpl::Time Time;
>
> typedef LegImpl::Pointer Pointer;
>
> typedef LegImpl::ConstPointer ConstPointer;
>
> typedef LegImpl::Reference Reference;
>
> typedef LegImpl::ConstReference ConstReference;
>
> typedef LegImpl::Iterator Iterator;
>
> typedef LegImpl::ConstIterator ConstIterator;
>
>
>
>
>
> Leg(void);
>
> Leg(size_t reserve_size);
>
> Leg(const Leg& that);
>
> Leg& operator=(const Leg& that);
>
> virtual ~Leg();
>
>
>
>
>
> size_t size(void) const;
>
> size_t size(bit_t flavor) const;
>
> void clear(void);
>
> err_t append(Leg& that);
>
> err_t push_back(LegSpecs::Entry* entry);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> err_t cache_entry(const std::string& name,size_t& pos);
>
> bool get_cache_entry(const std::string& name,size_t& pos) const;
>
> bool get_cache_entry(const std::string& name,bool require,size_t& pos) const;
>
> err_t add_cache_entry(const Leg& that);
>
>
>
>
>
> bool synchro_after(const Time& time,bit_t flavor,ConstIterator& iter) const;
>
> bool synchro_after(const Time& time,bit_t flavor,size_t offset_pos,ConstIterator& iter) const;
>
> bool synchro_after(const Time& time,bit_t flavor,size_t offset_pos,size_t default_pos,ConstIterator& iter) const;
>
> bool synchro_at(const Time& time,bit_t flavor,ConstIterator& iter) const;
>
> bool synchro_at(const Time& time,bit_t flavor,size_t offset_pos,ConstIterator& iter) const;
>
> bool synchro_at(const Time& time,bit_t flavor,size_t offset_pos,size_t default_pos,ConstIterator& iter) const;
>
> bool next(size_t step,bit_t flavor,ConstIterator& iter) const;
>
> bool next(size_t step,bit_t flavor,Iterator& iter);
>
> bool prev(size_t step,bit_t flavor,ConstIterator& iter) const;
>
> bool prev(size_t step,bit_t flavor,Iterator& iter);
>
>
>
>
>
> Iterator begin(bit_t flavor=Flavors::AllFlavors);
>
> ConstIterator begin(bit_t flavor=Flavors::AllFlavors) const;
>
> Iterator end(bit_t flavor=Flavors::AllFlavors);
>
> ConstIterator end(bit_t flavor=Flavors::AllFlavors) const;
>
> err_t front(FMR4000::Finance::LegSpecs::Entry*& ref,bit_t flavor=Flavors::AllFlavors);
>
> err_t front(const FMR4000::Finance::LegSpecs::Entry*& ref,bit_t flavor=Flavors::AllFlavors) const;
>
> err_t back(FMR4000::Finance::LegSpecs::Entry*& ref,bit_t flavor=Flavors::AllFlavors);
>
> err_t back(const FMR4000::Finance::LegSpecs::Entry*& ref,bit_t flavor=Flavors::AllFlavors) const;
>
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_leg;
>
> private:
> Cache index;
> };
>
> }
>
>}
>
>
>inline FMR4000::Finance::LegSpecs::Entry::Entry(void)
> : flavor(Flavors::AllFlavors), time(0), link(__null)
>{
> FMR::Platform::Lock<LockModel> lock(mx_legentry);
>}
>
>inline err_t FMR4000::Finance::LegSpecs::Entry::check(long old_time,size_t old_height)
>{
> FMR::Platform::Lock<LockModel> lock(mx_legentry);
> if (time>old_time) return 0x08c8;
> if (cache.size()!=old_height) return 0x08c9;
> return 0;
>}
>
>inline void FMR4000::Finance::LegSpecs::Entry::copy(const Entry& that)
>{
>
> FMR::Platform::Lock<LockModel> lock(mx_legentry);
> time = that.time;
> flavor = that.flavor;
> cache = that.cache;
> link = that.link;
>}
>
>inline long FMR4000::Finance::LegSpecs::Entry::get_time(size_t offset_pos) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_legentry);
>
> if (Cache::NPos==offset_pos) return time;
>
>
> long tmp = static_cast<long>(cache[offset_pos]);
> if (tmp==0) return time;
> return tmp;
>}
>
>
>inline bool FMR4000::Finance::Leg::synchro_after(const Time& time,bit_t flavor,ConstIterator& iter) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> iter = LegImpl::synchro_after(time);
> if (LegImpl::end()==iter) return false;
> return next(0,flavor,iter);
>}
>
>inline bool FMR4000::Finance::Leg::synchro_after(const Time& time,bit_t flavor,size_t offset_pos,ConstIterator& iter) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> iter = begin();
> ConstIterator e = end();
> for (long tmp;iter!=e;++iter)
> {
> tmp = (*iter)->get_time(offset_pos);
> if (time<tmp) return next(0,flavor,iter);
> }
> return false;
>}
>
>inline bool FMR4000::Finance::Leg::synchro_after(const Time& time,bit_t flavor,size_t offset_pos,size_t default_pos,ConstIterator& iter) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> if (Cache::NPos==offset_pos) offset_pos = default_pos;
> return synchro_after(time,flavor,offset_pos,iter);
>}
>
>inline bool FMR4000::Finance::Leg::synchro_at(const Time& time,bit_t flavor,ConstIterator& iter) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> iter = LegImpl::synchro_at(time);
> if (LegImpl::end()==iter) return false;
> return next(0,flavor,iter);
>}
>
>inline bool FMR4000::Finance::Leg::synchro_at(const Time& time,bit_t flavor,size_t offset_pos,ConstIterator& iter) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> iter = begin();
> ConstIterator e = end();
> for (long tmp;iter!=e;++iter)
> {
> tmp = (*iter)->get_time(offset_pos);
> if (!(tmp<time)) return next(0,flavor,iter);
> }
> return false;
>}
>
>inline bool FMR4000::Finance::Leg::synchro_at(const Time& time,bit_t flavor,size_t offset_pos,size_t default_pos,ConstIterator& iter) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> if (Cache::NPos==offset_pos) offset_pos = default_pos;
> return synchro_at(time,flavor,offset_pos,iter);
>}
>
>inline FMR4000::Finance::Leg::Iterator FMR4000::Finance::Leg::begin(bit_t flavor)
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> Iterator iter = LegImpl::begin();
> if (!next(0,flavor,iter)) return LegImpl::end();
> return iter;
>}
>
>inline FMR4000::Finance::Leg::ConstIterator FMR4000::Finance::Leg::begin(bit_t flavor) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> ConstIterator iter = LegImpl::begin();
> if (!next(0,flavor,iter)) return LegImpl::end();
> return iter;
>}
>
>inline FMR4000::Finance::Leg::Iterator FMR4000::Finance::Leg::end(bit_t flavor)
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> return LegImpl::end();
>}
>
>inline FMR4000::Finance::Leg::ConstIterator FMR4000::Finance::Leg::end(bit_t flavor) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_leg);
> return LegImpl::end();
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBuildAlgo.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace InstrSpecs {
>
> class Entry;
>
> }
>
>
> class BuildAlgo : public Service::Product
> {
> public:
>
>
>
>
> BuildAlgo& operator=(const BuildAlgo& that);
>
> virtual ~BuildAlgo();
>
>
>
>
>
> virtual bool need_input_leg(void) const;
>
> virtual bool need_markets(void) const;
>
> virtual bool need_ref_entry(void) const;
>
> virtual Service::Product* clone(void) const =0;
>
> virtual Service::Product* duplicate(void) const =0;
>
>
>
>
>
> virtual err_t validate(void) const =0;
>
> virtual err_t execute(InstrSpecs::Entry* entry,Service::BuildData* data) =0;
>
> virtual err_t build(Service::BuildData* data);
>
>
> protected:
>
> BuildAlgo(const std::string& type);
>
> virtual void assign(const BuildAlgo& that) =0;
> };
>
> }
>
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtData.h" 1
>
>
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrHub.h" 1
>
>
>
>
>
>
>
>namespace FMR {
>
> namespace Platform {
>
> template
> <
> typename Terminal,
> typename Value
> >
> class Device
> {
> public:
> Device(void) {}
> virtual ~Device() {}
>
> bool operator==(const Device& that) const;
> bool operator<(const Device& that) const;
>
> err_t activate(const Terminal& rtdata);
> err_t deactivate(const Terminal& rtdata);
>
> err_t get_value(Value& value) const;
> };
>
> template
> <
> typename Identifier,
> typename Terminal,
> typename Device
> >
> class Hub
> {
> public:
>
> Hub(const Terminal& terminal) : term(&terminal) {}
> Hub(const Hub& that) {copy(that);}
> Hub& operator=(const Hub& that) {if (&that!=this) {blank(); copy();} return this;}
> virtual ~Hub(void) {blank();}
>
> err_t plug(const Identifier& id,Device& device);
> err_t unplug(const Identifier& id);
>
> void reset(void);
>
> template <typename T>
> err_t get_value(const Identifier& id,T& value) const
> {
>
> typename RoutingTable::const_iterator route = table.find(id);
> if (table.end()==route) return 0x0184;
>
> typename Counters::const_iterator status = counters.find(*route->second);
> if (!status->second) return 0x0185;
>
> return route->second->get_value(value);
> }
>
> private:
>
> void blank(void);
> void copy(const Hub& that);
>
> typedef const Device* DevicePtr;
> typedef std::map<Identifier,DevicePtr> RoutingTable;
> typedef std::map<Device,short> Counters;
>
> RoutingTable table;
> mutable Counters counters;
>
> const Terminal* term;
> };
>
> }
>
>}
>
>
>template<typename Id,typename Term,typename Dev>
>err_t FMR::Platform::Hub<Id,Term,Dev>::plug(const Id& id,Dev& dev)
>{
>
> if (table.end()!=table.find(id))
> {
> err_t is_err = unplug(id);
> if (is_err) return is_err;
> }
>
>
> typename Counters::iterator status = counters.find(dev);
> if (counters.end()==status)
> {
>
> err_t is_err = dev.activate(*term);
> if (is_err) return is_err;
> status = counters.insert((typename Counters::value_type(dev,0))).first;
> }
>
>
> ++status->second;
>
>
> table.insert((typename RoutingTable::value_type(id,&status->first)));
> return 0;
>}
>
>
>template<typename Id,typename Term,typename Dev>
>err_t FMR::Platform::Hub<Id,Term,Dev>::unplug(const Id& id)
>{
>
> typename RoutingTable::iterator route = table.find(id);
> if (table.end()==route) return 0x0184;
>
>
> DevicePtr pdev = route->second;
> table.erase(route);
>
>
> typename Counters::iterator status = counters.find(*pdev);
> if (!status->second) return 0;
> --status->second;
> return 0;
>}
>
>
>template<typename Id,typename Term,typename Dev>
>void FMR::Platform::Hub<Id,Term,Dev>::reset(void)
>{
>
> table.clear();
>
>
> for (typename Counters::iterator status=counters.begin(),e=counters.end();status!=e;++status)
> status->second = 0;
>}
>
>
>template<typename Id,typename Term,typename Dev>
>void FMR::Platform::Hub<Id,Term,Dev>::blank(void)
>{
>
> table.clear();
>
>
> for (typename Counters::iterator status=counters.begin(),e=counters.end();status!=e;++status)
> {
> status->second = 0;
> Dev* pdev = const_cast<Dev*>(&status->first);
> pdev->deactivate(*term);
> }
>
>
> counters.clear();
>}
>
>
>template<typename Id,typename Term,typename Dev>
>void FMR::Platform::Hub<Id,Term,Dev>::copy(const Hub<Id,Term,Dev>& that)
>{
> table = that.table;
> counters = that.counters;
> term = that.term;
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtData.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrString.h" 1
>
>
>
>
>
>
>
>namespace FMR {
>
> namespace Platform {
>
> class UncasedString
> {
> public:
> UncasedString(const char* str) : s(str) {}
> UncasedString(const std::string& str) : s(str) {}
> virtual ~UncasedString() {}
>
> operator std::string () const {return s;}
>
> bool operator==(const UncasedString& that) const;
> bool operator<(const UncasedString& that) const;
>
> static inline int compare(const char* first,const char* second);
> static inline int compare_n(const char* first,const char* second,size_t nmax);
>
> std::string s;
> };
>
> template<char Wildcard,char Delimiter>
> class RegularString
> {
> public:
> RegularString(const char* str) : s(str), sc(s+".") {is_wild = (s.find(Wildcard)<s.size());}
> RegularString(const std::string& str) : s(str), sc(s+".") {is_wild = (s.find(Wildcard)<s.size());}
> virtual ~RegularString() {}
>
> operator std::string () const {return s;}
>
> bool operator==(const RegularString& that) const;
> bool operator<(const RegularString& that) const;
>
> std::string token(const std::string& x,size_t& pos) const;
>
> std::string s;
> std::string sc;
> bool is_wild;
> };
>
> }
>
>}
>
>
>inline int FMR::Platform::UncasedString::compare(const char* first,const char* second)
>{
>
>
>
>
>
>
>
> while (*first && *second)
> {
> if (toupper(*first)!=toupper(*second)) break;
> first++;
> second++;
> }
> if (toupper(*first)==toupper(*second)) return 0;
> else if (toupper(*first)<toupper(*second)) return -1;
> return 1;
>
>}
>
>
>inline int FMR::Platform::UncasedString::compare_n(const char* first,const char* second,size_t nmax)
>{
>
>
>
>
>
>
>
> while (*first && *second && nmax)
> {
> if (toupper(*first)!=toupper(*second)) break;
> nmax--;
> first++;
> second++;
> }
> if (0==nmax) return 0;
> if (toupper(*first)==toupper(*second)) return 0;
> else if (toupper(*first)<toupper(*second)) return -1;
> return 1;
>
>}
>
>
>inline bool FMR::Platform::UncasedString::operator==(const UncasedString& that) const
>{
> size_t size = s.size();
> if (size!=that.s.size()) return false;
> return 0==compare_n(s.c_str(),that.s.c_str(),size);
>}
>
>
>inline bool FMR::Platform::UncasedString::operator<(const UncasedString& that) const
>{
> size_t size_this = s.size();
> size_t size_that = that.s.size();
> int result = compare_n(s.c_str(),that.s.c_str(),size_this);
> if (size_this!=size_that && 0==result) return size_this<size_that;
> return 0>result;
>}
># 8 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtData.h" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBondMarket.h" 1
>
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrOffset.h" 1
># 9 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrOffset.h"
>namespace FMR4000 {
>
> namespace Finance {
>
> class OffsetOpt : public Service::Product
> {
> public:
>
> legenda_t mode;
>
> lag_t lag;
>
>
>
>
> OffsetOpt(void);
>
> OffsetOpt(const OffsetOpt& that);
>
> OffsetOpt& operator=(const OffsetOpt& that);
>
> virtual ~OffsetOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
> private:
> void copy(const OffsetOpt& that);
> };
>
> err_t GetTrade(long trade,long settlement,const std::string& calendar,const OffsetOpt& settl_opt,long& date);
> err_t GetSettlement(long trade,long settlement,long accrual_start,const std::string& calendar,const OffsetOpt& settl_opt,long& date);
>
> }
>
>}
># 6 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBondMarket.h" 2
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRate.h" 1
># 20 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRate.h"
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrRound.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/platform/fmrTypes.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/numerics/fmrRound.h" 2
>
>
>namespace FMR {
>
> namespace Numerics {
>
> const legenda_t eRound = 1;
> const legenda_t eTruncate = 2;
> const legenda_t eFloor = 3;
> const legenda_t eCeiling = 4;
> const legenda_t eNearest51 = 5;
>
> class RoundOpt
> {
> public:
> RoundOpt(void) {init();}
> virtual ~RoundOpt() {}
>
>
> double rounding(double number,err_t& err) const;
>
> void init(void);
>
> unsigned short figures;
>
> legenda_t method;
>
> private:
> double simple_rounding(double number) const;
> double truncate(double number) const;
> double flooring(double number) const;
> double ceiling(double number) const;
>
> double nearest51(double number) const;
> };
>
>
> }
>
>}
># 21 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRate.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace Frequency {
>
>
>
>
> const legenda_t Simple = 1;
>
> const legenda_t Compounded = 2;
>
> const legenda_t Continuous = 3;
>
> const legenda_t MoneyMarket = 4;
>
>
>
>
> }
>
>
> class ActactOpt
> {
> public:
>
>
>
> tenor_t tenor;
>
> bool use_leap;
>
> legenda_t eom;
>
>
>
>
>
> ActactOpt(void);
>
> virtual ~ActactOpt();
>
>
>
>
>
> void init(void);
>
> };
>
>
> class RateOpt : public Service::Product
> {
> public:
>
>
>
> double face_value;
>
> tenor_t tenor;
>
> legenda_t base;
>
> legenda_t mode;
>
> tenor_t comp_tenor;
>
> bool use_leap;
>
> ActactOpt actact;
>
> FMR::Numerics::RoundOpt rounding;
>
>
>
>
>
> RateOpt(void);
>
> explicit RateOpt(legenda_t rate_mode);
>
> RateOpt(const RateOpt& that);
>
> RateOpt& operator=(const RateOpt& that);
>
> virtual ~RateOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void) const;
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
> private:
> void copy(const RateOpt& that);
> };
>
>
> namespace Time {
>
>
> err_t DistDates(long start_jday,long end_jday,long roll_jday,const RateOpt& rate_opt,double& disc);
>
>
>
>
> tenor_t GetTenor(const std::string& time);
>
> bool ExtractStandardTime(const std::string& name,std::string& convention,std::string& time);
>
> void GetSwapName(std::string& name,long settlement,long accrual_start);
>
>
> }
>
>
> namespace Rate {
># 162 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRate.h"
> err_t Rate2Disc(
> double tau,
>
> double disc_start,
>
> double rate,
>
> const RateOpt& conv,
>
> double& disc_end);
>
> err_t Rate2Disc(
> long start_jday,
>
> long end_jday,
>
> long roll_jday,
>
> double disc_start,
>
> double rate,
>
> const RateOpt& conv,
>
> double& disc_end);
>
> err_t Disc2Rate(
> double tau,
>
> double disc_start,
>
> double disc_end,
>
> const RateOpt& conv,
>
> double& fwd_rate);
>
> err_t Disc2Rate(
> long start_jday,
>
> long end_jday,
>
> long roll_jday,
>
> double disc_start,
>
> double disc_end,
>
> const RateOpt& conv,
>
> double& fwd_rate);
>
> err_t Interest(
> double tau,
>
> double rate,
>
> const RateOpt& conv,
>
> double& inter);
>
> err_t Interest(
> long start_jday,
>
> long end_jday,
>
> long roll_jday,
>
> double rate,
>
> const RateOpt& conv,
>
> double& inter);
>
> err_t IssuePriceRicap(
> long rate_start_jday,
>
> long rate_end_jday,
>
> long interest_start_jday,
>
> long interest_end_jday,
>
> long roll_jday,
>
> double disc_start,
>
> double disc_end,
>
> const RateOpt& conv,
>
> double& ip_ricap);
>
>
> }
>
> }
>
>}
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrBondMarket.h" 2
>
>namespace FMR4000 {
>
> namespace Finance {
>
> namespace BuildMode {
>
>
>
>
> const bit_t ZeroCoupon = 0x0001;
>
> const bit_t SinkingFund = 0x0002;
>
> const bit_t BrokenCoupon = 0x0004;
>
> const bit_t Rolling = 0x0008;
>
>
> }
>
>
> class BuildOpt : public MarketSpecs::Entry
> {
> public:
>
>
>
> RateOpt rate_opt;
>
> bit_t instr_type;
>
> bool is_effd;
>
> tenor_t red_tenor;
>
> tenor_t build_tenor;
>
> std::string calendar;
>
> legenda_t red_plan;
>
> OffsetOpt effd_opt;
>
> OffsetOpt exdiv_opt;
>
> OffsetOpt reset_opt;
>
> long fmr4000_version;
>
>
>
>
>
> BuildOpt(void);
>
> BuildOpt(const BuildOpt& that);
>
> BuildOpt& operator=(const BuildOpt& that);
>
> virtual ~BuildOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& build_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> private:
> void copy(const BuildOpt& that);
> virtual void assign(const MarketSpecs::Entry& that);
> };
>
>
> class SettlementOpt : public MarketSpecs::Entry
> {
> public:
>
>
>
> std::string calendar;
>
> OffsetOpt settl_opt;
>
>
>
>
>
> SettlementOpt(void);
>
> SettlementOpt(const SettlementOpt& that);
>
> SettlementOpt& operator=(const SettlementOpt& that);
>
> virtual ~SettlementOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& build_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> private:
> void copy(const SettlementOpt& that);
> virtual void assign(const MarketSpecs::Entry& that);
> };
>
>
> namespace FutureMarket {
>
>
>
> const legenda_t Liffe = 1;
> const legenda_t Eurex = 2;
> const legenda_t Cbot = 3;
> const legenda_t Tase = 4;
>
>
> }
>
>
> class FutureOpt : public MarketSpecs::Entry
> {
> public:
>
>
>
> std::string calendar;
>
> legenda_t market;
>
> double notional_rate;
>
> long notional;
>
> RateOpt rate_opt;
>
> long delivery_day;
>
> legenda_t delivery_mode;
>
>
>
>
>
> FutureOpt(void);
>
> FutureOpt(const FutureOpt & that);
>
> FutureOpt& operator=(const FutureOpt& that);
>
> virtual ~FutureOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& future_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> private:
> void copy(const FutureOpt& that) ;
> virtual void assign(const MarketSpecs::Entry& that);
> };
>
>
> namespace AccrintMode {
>
>
>
>
> const legenda_t Standard = 1;
>
> const legenda_t RoundOnce = 2;
>
> const legenda_t CalcFromRate = 3;
>
> const legenda_t ZCSimple = 4;
>
> const legenda_t ZCCompound = 5;
>
>
> const legenda_t OatiType = 6;
>
> const legenda_t RollingInstrument = 99;
>
>
> }
>
>
> class AccrintOpt : public MarketSpecs::Entry
> {
> public:
>
>
>
> RateOpt rate_opt;
>
> legenda_t mode;
>
> bool is_effd;
>
> bool neg_after_exdiv;
>
> legenda_t second_base;
>
> double issue_price;
>
> bool is_ffc;
>
> double inflbase_index;
>
> short is_flat;
>
>
>
>
>
> AccrintOpt(void);
>
> AccrintOpt(const AccrintOpt& that);
>
> AccrintOpt& operator=(const AccrintOpt& that);
>
> virtual ~AccrintOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& build_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> private:
> void copy(const AccrintOpt& that);
> virtual void assign(const MarketSpecs::Entry& that);
> };
>
>
> class YieldOpt : public MarketSpecs::Entry
> {
> public:
>
>
>
> RateOpt rate_opt;
>
> bool is_effd;
>
>
>
>
>
> YieldOpt(void);
>
> YieldOpt(const YieldOpt& that);
>
> YieldOpt& operator=(const YieldOpt& that);
>
> virtual ~YieldOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& build_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> private:
> void copy(const YieldOpt& that);
> virtual void assign(const MarketSpecs::Entry& that);
> };
>
>
> class EquityOpt : public MarketSpecs::Entry
> {
> public:
>
>
>
> double specific_weight;
>
> double min_specific_weight;
>
> double max_specific_weight;
>
> double category_weight;
>
> int underlying_pos;
>
> std::string currency;
>
> double fixed_crossrate;
>
> std::string hist_series;
>
> double quantity;
>
>
>
>
>
> EquityOpt(void);
>
> EquityOpt(const EquityOpt& that);
>
> EquityOpt& operator=(const EquityOpt& that);
>
> virtual ~EquityOpt();
>
>
>
>
>
> void init(void);
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> virtual void match(const std::string& entry_name,MarketOpt& market_opt,const MarketOpt& build_opt,Service::ProxyType* pxvarg) const;
>
> virtual err_t get_varg(const std::string& prefix,Service::ProxyType* pxvarg) const;
>
>
> private:
> void copy(const EquityOpt& that);
> virtual void assign(const MarketSpecs::Entry& that);
> };
>
> }
>
>}
># 10 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRtData.h" 2
>
>
>
>
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> class RtData : public Service::BaseObj
> {
> public:
>
>
>
>
> RtData(void);
>
> RtData(const RtData& that);
>
> RtData& operator=(const RtData& that);
>
> virtual ~RtData();
>
>
>
>
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
>
>
>
> err_t update_string(const std::string& key,const std::string& value,const std::string& type);
>
> err_t update_rate(const std::string& key,const RateOpt& value,const std::string& type="value");
>
> err_t update_offset(const std::string& key,const OffsetOpt& value,const std::string& type="value");
>
> err_t update_effd_offset(const std::string& key,const OffsetOpt& value,const std::string& type="value");
>
> err_t update_exdiv_offset(const std::string& key,const OffsetOpt& value,const std::string& type="value");
>
> err_t update_reset_offset(const std::string& key,const OffsetOpt& value,const std::string& type="value");
>
> template <typename T>
> err_t update_value(const std::string& key,const T& value,const std::string& type="value")
> {
> FMR::Platform::Lock<LockModel> lock(mx_val);
> std::stringstream ss;
> ss.precision(16);
> ss << value;
> return update_string(key,ss.str(),type);
> }
>
> err_t erase(const std::string& key);
>
> void clear(void);
>
>
>
>
>
> err_t next(std::string& key,std::string& value,std::string& type) const;
>
> err_t match_key(const std::string& key,const std::string& type,std::string& matching_key) const;
>
> err_t get_proxy(const std::string& key,Service::ProxyType*& proxy) const;
>
> err_t get_object(const std::string& key,std::string& name,std::string& type) const;
>
> template <typename AccessPolicy>
> err_t get_handle(const std::string& key,AccessPolicy& at_obj,typename AccessPolicy::Handle& handle) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_val);
> Service::ProxyType* proxy = __null;
> err_t err = get_proxy(key,proxy);
> if (err) return err;
> at_obj.assign(proxy);
> handle = at_obj.get_handle();
> if (handle) return 0;
> at_obj.blank();
> return 0x08d8;
> }
>
> err_t get_string(const std::string& key,std::string& value) const;
>
> err_t get_rate(const std::string& key,RateOpt& value) const;
>
> err_t get_offset(const std::string& key,OffsetOpt& value) const;
>
> err_t get_reset_offset(const std::string& key,OffsetOpt& value) const;
>
> err_t get_effd_offset(const std::string& key,OffsetOpt& value) const;
>
> err_t get_exdiv_offset(const std::string& key,OffsetOpt& value) const;
>
> template <typename T>
> err_t get_value(const std::string& key,T& value) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_val);
> std::string s;
> err_t is_err = get_string(key,s);
> if (is_err) return is_err;
> std::stringstream ss(s);
> ss.precision(16);
> ss >> value;
> return 0;
> }
>
> err_t get_accrint_opt(const std::string& entry_name,AccrintOpt* varg_opt);
>
> err_t get_build_opt(const std::string& entry_name,BuildOpt* varg_opt);
>
> err_t get_future_opt(const std::string& entry_name,FutureOpt* varg_opt);
>
> err_t get_settlement_opt(const std::string& entry_name,SettlementOpt* varg_opt);
>
> err_t get_yield_opt(const std::string& entry_name,YieldOpt* varg_opt);
>
> err_t setup_shorters(const std::string& isin,const std::string& last_token) const;
>
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_val;
>
> private:
>
> class Impl
> {
> public:
> Impl(RtData& rtdata);
> virtual ~Impl();
>
> class SysObj
> {
> public:
> SysObj(const std::string& obj_name,const std::string& obj_type);
> SysObj(const SysObj& that);
> SysObj& operator=(const SysObj& that);
> virtual ~SysObj();
>
> void copy(const SysObj& that);
>
> bool operator==(const SysObj& that) const;
> bool operator<(const SysObj& that) const;
>
> err_t activate(const RtData& rtdata);
> err_t deactivate(const RtData& rtdata);
>
> err_t get_value(Service::ProxyType*& proxy) const;
>
> std::string name;
> std::string type;
> Service::ProxyType* px;
> private:
> mutable LockModel mx_so;
> };
>
> class Value
> {
> public:
> Value(void);
> Value(const std::string& data_value,const std::string& data_mode);
> virtual ~Value();
>
> std::string value;
> std::string mode;
> };
>
> template <unsigned char Number,unsigned char Delimiter,unsigned char Wildcard>
> class Tokens
> {
> public:
> Tokens(void);
> Tokens(const std::string& key);
> virtual ~Tokens();
>
> operator std::string () const;
>
> bool is_wild;
> std::string token[Number];
>
> bool operator==(const Tokens& that) const;
> bool operator<(const Tokens& that) const;
>
> private:
> mutable LockModel mx_token;
> };
>
>
> bool find_isin(const std::string& isin) const;
>
>
> template <typename SearchList>
> err_t find_by_token(const SearchList& slist,const std::string& key,typename SearchList::const_iterator& iter) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_impl);
> iter = slist.find(key);
> typename SearchList::const_iterator e = slist.end();
> if (iter==e)
> {
> std::string str = "";
> WildKey tk(key);
>
> if (tk.token[0] != "*")
> {
> str = tk.token[0];
> tk.token[0] = "*";
> iter = slist.find(static_cast<std::string>(tk));
> if (iter!=e) return 0;
> tk.token[0] = str;
> }
>
> if (tk.token[1] != "*")
> {
> str = tk.token[1];
> tk.token[1] = "*";
> iter = slist.find(static_cast<std::string>(tk));
> if (iter!=e) return 0;
> tk.token[1] = str;
> }
>
> if (tk.token[0] != "*" && tk.token[1] != "*")
> {
> tk.token[0] = "*";
> tk.token[1] = "*";
> iter = slist.find(static_cast<std::string>(tk));
> if (iter!=e) return 0;
> }
> return 0x08d6;
> }
> return 0;
> }
>
>
> template <typename SearchList,typename AnyList>
> err_t find(const SearchList& slist,const AnyList& alist,const std::string& key,typename SearchList::const_iterator& iter) const
> {
> FMR::Platform::Lock<LockModel> lock(mx_impl);
> iter = slist.find(key);
> typename SearchList::const_iterator e = slist.end();
> if (iter==e)
> {
> typename AnyList::const_iterator q = std::find(alist.begin(),alist.end(),key);
> if (q==alist.end())
> {
> return 0x08d6;
> }
> iter = slist.find(static_cast<std::string>(*q));
> if (iter==e)
> {
> return 0x08d6;
> }
> }
> return 0;
> }
>
> typedef FMR::Platform::UncasedString Key;
> typedef std::map<Key,Value> ValueList;
> typedef FMR::Platform::Hub<Key,RtData,SysObj> ObjList;
> typedef std::map<Key,SysObj> ObjInfo;
> typedef Tokens<3,'.','*'> WildKey;
> typedef std::set<WildKey> AnyValueList;
> typedef std::map<Key,short> IsinInfo;
> typedef std::set<WildKey> AnyObjInfo;
>
> ValueList values;
> ObjList objects;
> ObjInfo objinfo;
> AnyValueList any_values;
> IsinInfo isin_values;
> AnyObjInfo any_objinfo;
>
> bit_t flv_rate;
> bit_t flv_accr;
> bit_t flv_fut;
> bit_t flv_sett;
> bit_t flv_yld;
>
> private:
> mutable LockModel mx_impl;
> };
>
> Impl* impl;
>
> void blank(void);
> void copy(const RtData& that);
> };
>
> }
>
>}
># 8 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> class Instrument;
>
>
> namespace InstrSpecs {
>
> class Entry : public Service::Product
> {
> public:
>
> typedef FMR::Platform::Array
> <
> FMR::Platform::ArrayTraits::ArrayOfPointers
> <
> BuildAlgo
> >
> > Algorithms;
>
>
> typedef FMR::Platform::Array
> <
> FMR::Platform::ArrayTraits::ArrayOfPointers
> <
> RunTimeAlgo
> >
> > RtAlgorithms;
>
>
> typedef FMR::Platform::Array
> <
> FMR::Platform::ArrayTraits::ArrayOfPointers
> <
> Market
> >
> > Markets;
>
>
>
> class InputLegEntry
> {
> public:
> InputLegEntry(void);
> virtual ~InputLegEntry();
>
> typedef std::map<std::string,double> CacheStore;
> double time;
> CacheStore cache;
>
> InputLegEntry* clone(void);
> InputLegEntry* duplicate(void);
> };
>
>
> typedef FMR::Platform::Array
> <
> FMR::Platform::ArrayTraits::ArrayOfPointers
> <
> InputLegEntry
> >
> > InputLeg;
>
>
>
>
>
> std::string identifier;
>
>
>
>
>
>
>
> std::string category;
>
>
>
> bit_t flavor;
># 100 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h"
> Algorithms specs;
># 110 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h"
> RtAlgorithms rts;
># 121 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h"
> Markets markets;
>
>
>
>
> Leg leg;
>
>
>
>
>
> InputLeg input;
>
>
>
>
>
>
>
> const Entry* ref_entry;
>
>
>
> const Instrument* ref_instrument;
>
>
>
>
> Entry(void);
>
> Entry(const Entry& that);
>
> Entry& operator=(const Entry& that);
>
> virtual ~Entry();
>
>
>
>
>
> err_t get_market(long settlement,const std::string& market_name,MarketOpt& market_opt,Service::ProxyType* pxvarg=__null) const;
>
> err_t check_rtalgo(const std::string& prefix,const std::string& algo_name,RtAlgo& rtalgo,Service::ProxyType* pxvarg=__null) const;
>
> err_t get_rtalgo(const std::string& prefix,long trade,long settlement,const std::string& algo_name,RtAlgo& rtalgo,Service::ProxyType* pxvarg=__null) const;
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t validate(void);
>
> virtual err_t build(Service::BuildData* data);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
>
>
> private:
> err_t check(void);
> void copy(const Entry& that);
> };
>
> }
>
>
> class Instrument : public Service::BaseObj
> {
> public:
>
> typedef FMR::Platform::Array
> <
> FMR::Platform::ArrayTraits::ArrayOfPointers
> <
> InstrSpecs::Entry
> >
> > Book;
>
>
> typedef std::map<std::string,std::string> Info;
>
>
>
>
>
>
>
> std::string identifier;
>
>
>
>
> std::string description;
>
>
>
>
> Info info;
>
>
>
>
>
>
>
> Book book;
>
>
>
>
> Service::ProxyType* pxvarg;
>
>
>
>
>
> Instrument(void);
>
> Instrument(const Instrument& that);
>
> Instrument& operator=(const Instrument& that);
>
> virtual ~Instrument();
>
>
>
>
>
> virtual Service::Product* clone(void) const;
>
> virtual Service::Product* duplicate(void) const;
>
> virtual err_t build(Service::BuildData* data);
>
> virtual err_t validate(void);
>
> virtual void write(FMR::Streaming::Formatter& stream,const std::string& name) const;
>
> virtual err_t read(FMR::Streaming::Browser& parser,const std::string& name);
>
> const char* get_name();
># 280 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h"
> err_t get_trade(
> long trade,
>
> long settlement,
>
> Service::ProxyType* pxvarg,
>
> long& ret_tr) const;
>
> err_t get_settlement(
> long trade,
>
> long settlement,
>
> long accrual_start,
>
> Service::ProxyType* pxvarg,
>
> long& ret_settl) const;
>
> err_t get_entry(Book::const_iterator& iter) const;
>
> err_t get_market(
> long settlement,
>
> const std::string& market_name,
>
> MarketOpt& market_opt,
>
> Service::ProxyType* pxvarg=__null) const;
>
> err_t check_rtalgo(
> const std::string& prefix,
>
> const std::string& algo_name,
>
> RtAlgo& rtalgo,
>
> Service::ProxyType* pxvarg=__null) const;
>
> err_t get_rtalgo(
> const std::string& prefix,
>
> long trade,
>
> long settlement,
>
> const std::string& algo_name,
>
> RtAlgo& rtalgo,
>
> Service::ProxyType* pxvarg=__null) const;
># 342 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h"
> err_t opt_price(
> long trade,
>
> long settlement,
>
> Service::ProxyType* pxreport,
>
> Service::ProxyType* pxcurve,
>
> Service::ProxyType* pxvarg,
>
> double& rval) const;
># 365 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrInstrument.h"
> err_t visit(InstrSpecs::Visitor* visitor) const;
>
> err_t retrieve_issue(bit_t entry_name,long& ret_issue) const;
>
> err_t retrieve_maturity(bit_t entry_name,long& ret_mat) const;
>
> err_t get_trade(
> long trade,
>
> long settlement,
>
> bit_t entry_name,
>
> Service::ProxyType* pxvarg,
>
> long& ret_tr) const;
>
> err_t get_settlement(
> long trade,
>
> long settlement,
>
> long accrual_start,
>
> bit_t entry_name,
>
> Service::ProxyType* pxvarg,
>
> long& ret_settl) const;
>
> err_t get_entry(bit_t name,Book::const_iterator& iter) const;
>
> err_t get_market(
> long settlement,
>
> bit_t entry_name,
>
> const std::string& market_name,
>
> MarketOpt& market_opt,
>
> Service::ProxyType* pxvarg=__null) const;
>
> err_t check_rtalgo(
> const std::string& prefix,
>
> bit_t entry_name,
>
> const std::string& algo_name,
>
> RtAlgo& rtalgo,
>
> Service::ProxyType* pxvarg=__null) const;
>
> err_t get_rtalgo(
> const std::string& prefix,
>
> long trade,
>
> long settlement,
>
> bit_t entry_name,
>
> const std::string& algo_name,
>
> RtAlgo& rtalgo,
>
> Service::ProxyType* pxvarg=__null) const;
>
> err_t get_marketprice(
> long settl,
>
> double mkprice,
>
> bool from_to_price,
>
> double& mkt_pr) const;
>
> err_t get_marketprice(
> long settl,
>
> double mkprice,
>
> bool from_to_price,
>
> bit_t entry_name,
>
> double& mkt_pr) const;
>
> err_t get_marketprice(
> long settl,
>
> double mkprice,
>
> bool from_to_price,
>
> bit_t entry_name,
>
> RtAlgo* rtalgo,
>
> Service::ProxyType* pxvarg,
>
> double& mkt_pr) const;
>
> bool get_subinstr_name(std::string& prev_subinstr) const;
>
>
>
> private:
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_instr;
>
> err_t check(void);
> void copy(const Instrument& that);
> };
>
>
> namespace InstrSpecs {
>
> class SubInstrIter
> {
> public:
>
> typedef Instrument::Book::const_iterator BookKiter;
>
> SubInstrIter(const Instrument* Pp, bit_t leg_type,short position);
> virtual ~SubInstrIter();
>
> const Entry* operator->() const;
> bool operator!(void);
> SubInstrIter& operator=(const SubInstrIter& that);
> SubInstrIter(const SubInstrIter& that);
>
> void copy(const SubInstrIter& that);
>
>
>
> bool next(bit_t leg_type);
>
> bool has_sub_instr(bit_t leg_type);
>
> short size(bit_t leg_type);
>
>
> private:
> const Instrument* instr_ptr;
> BookKiter p, e, main;
> short pos;
> };
>
> }
>
> }
>
>}
>
>
>inline err_t FMR4000::Finance::Instrument::visit(InstrSpecs::Visitor* visitor) const
>{
> FMR::Platform::Lock<LockModel> lock(mx_instr);
> if (visitor) return visitor->accept(this);
> return 0x0402;
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_settlement(long trade,long settlement,long accrual_start,Service::ProxyType* pxvarg,long& ret_settl) const
>{
> return get_settlement(trade,settlement,accrual_start,Flavors::Main,pxvarg,ret_settl);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_trade(long trade,long settlement,Service::ProxyType* pxvarg,long& ret_tr) const
>{
> return get_trade(trade,settlement,Flavors::Main,pxvarg,ret_tr);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_entry(Book::const_iterator& p) const
>{
> return get_entry(Flavors::Main,p);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_market(long settlement,const std::string& market_name,MarketOpt& market_opt,Service::ProxyType* pxvarg) const
>{
> return get_market(settlement,Flavors::Main,market_name,market_opt,pxvarg);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::check_rtalgo(const std::string& prefix,const std::string& algo_name,RtAlgo& rtalgo,Service::ProxyType* pxvarg) const
>{
> return check_rtalgo(prefix,Flavors::Main,algo_name,rtalgo,pxvarg);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_rtalgo(const std::string& prefix,long trade,long settlement,const std::string& algo_name,RtAlgo& rtalgo,Service::ProxyType* pxvarg) const
>{
> return get_rtalgo(prefix,trade,settlement,Flavors::Main,algo_name,rtalgo,pxvarg);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_marketprice(long settl,double mkprice,bool from_to_price,double& mkt_pr) const
>{
> return get_marketprice(settl,mkprice,from_to_price,Flavors::Main,__null,__null,mkt_pr);
>}
>
>
>inline err_t FMR4000::Finance::Instrument::get_marketprice(long settl,double mkprice,bool from_to_price, bit_t entry_name,double& mkt_pr) const
>{
> return get_marketprice(settl,mkprice,from_to_price,entry_name,__null,__null,mkt_pr);
>}
># 6 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrOptPayoff.h" 2
>
>namespace FMR4000 {
>
> namespace Finance {
>
> class OptPayoff : public RunTimeAlgo
> {
> public:
>
>
>
> OptPayoff& operator=(const OptPayoff& that);
>
> virtual ~OptPayoff();
>
>
>
>
>
> virtual err_t get_visitor(Service::ProxyType* pxreport,Service::ProxyType* pxcurve,InstrSpecs::Visitor*& pricer,Leg* leg) =0;
>
> virtual err_t control_variate(double& option_value);
>
>
> protected:
>
> OptPayoff(const std::string& type);
> };
>
> }
>
>}
># 4 "fmrBasketPricer.c" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/curve/fmrCurve.h" 1
>
>
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/instrument/fmrRate.h" 1
># 5 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/curve/fmrCurve.h" 2
>
># 1 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/service/fmrBaseObject.h" 1
># 7 "/home/FMRCONS/mmazza/MANUAL/fmr4000_finance/etc/../src/finance/curve/fmrCurve.h" 2
>
>
>namespace FMR4000 {
>
> namespace Finance {
>
> class Curve : public Service::BaseObj
> {
> public:
>
>
>
> Curve& operator=(const Curve& that);
>
> virtual ~Curve();
>
>
>
>
>
> virtual Service::Product* clone(void) const =0;
>
> virtual Service::Product* duplicate(void) const =0;
>
>
>
>
>
> virtual err_t kick(double delta,tenor_t tenor,bool is_forward,const RateOpt& conv);
>
> virtual err_t shiftdates(long new_ref_date);
>
>
>
>
>
> virtual err_t discount(long end,double& disc) const =0;
> virtual err_t discount(double end,double& disc) const =0;
>
> virtual err_t discount(long start,long end,double& disc) const =0;
> virtual err_t discount(double start,double end,double& disc) const =0;
>
> virtual err_t forward(long start,long end,const RateOpt& conv,double& result) const =0;
>
> virtual err_t spot(long end,const RateOpt& conv,double& result) const =0;
>
>
> typedef FMR::Platform::OnOffLocker<> LockModel;
> mutable LockModel mx_curve;
>
> protected:
>
> Curve(const std::string& type);
>
> virtual void assign(const Curve& that) =0;
> };
>
> }
>
>}
># 6 "fmrBasketPricer.c" 2
>
>
>FMR4000::Finance::Visitors::Montecarlo::Montecarlo(long trade,long settlement,FMR::Numerics::Vector& asset_basket,FMR::Numerics::Vector& gr_rate,FMR::Numerics::Vector& vol_vect,FMR::Numerics::SymmetricMatrix cor_mat,RunTimeAlgo* rtalgo,Service::ProxyType* report,const std::string& underlying_name,const std::string& prefix_name,const InstrSpecs::Entry* instr_entry,Service::ProxyType* curve,Service::ProxyType* varg)
> : trd(trade), settl(settlement),
> basket(asset_basket), growth_rate(gr_rate), volatility_vect(vol_vect), correlation_matrix(cor_mat),
> entry(instr_entry), payoff(rtalgo),
> pxreport(report),underlying(underlying_name),prefix(prefix_name),pxcurve(curve),pxvarg(varg)
>{}
>
>err_t FMR4000::Finance::Visitors::Montecarlo::connect(const Instrument* instrument)
>{
> err_t err = disconnect(instrument);
> return err;
>}
>
>err_t FMR4000::Finance::Visitors::Montecarlo::disconnect(const Instrument* instrument)
>{
> return 0;
>}
>
>err_t FMR4000::Finance::Visitors::Montecarlo::calculate(const Instrument* instrument)
>{
> err_t err = 0;
>
> typedef Service::AccessObj<Curve,Service::ReadOnly> CurveAT;
> CurveAT::Handle hcurve = CurveAT::get_handle(pxcurve);
> if (!hcurve) return 0x0920;
>
> if (entry->leg.empty()) return 0x08c2;
>
>
> size_t asset_pos,out_pos,payoff_pos,strike_pos;
> if (!entry->leg.get_cache_entry("Asset",asset_pos) ||
> !entry->leg.get_cache_entry("Strike",strike_pos) ||
> !entry->leg.get_cache_entry("Payoff",payoff_pos)) return 0x0922;
> bool has_out = entry->leg.get_cache_entry("Outstanding",out_pos);
>
> size_t stock_dim=basket.size();
>
>
> long maxloop = 100;
> double vol = 0.0, gr_rate=0.0, spot_asset=0.0,vol_thres=0.0;
> size_t vol_dim = 0, control_var=2;
>
> {
> typedef Service::AccessObj<RtData,Service::ReadOnly> VargAT;
> VargAT::Handle hvarg = VargAT::get_handle(pxvarg);
> if (hvarg)
> {
> hvarg->get_value(prefix+"MaxLoop",maxloop);
> hvarg->get_value(prefix+"Threshold",vol_thres);
> hvarg->get_value(prefix+"Dimension",vol_dim);
> hvarg->get_value(prefix+"ControlVariate",control_var);
> }
> if (maxloop<100) maxloop = 100;
> }
>
> FMR::Numerics::Vector start_drift(stock_dim,0.0);
> FMR::Numerics::Vector drift_vect(stock_dim,0.0);
> FMR::Numerics::Vector start_vol(stock_dim,0.0);
> FMR::Numerics::Vector zero(stock_dim,0.0);
> FMR::Numerics::Vector short_drift(stock_dim,0.0);
> FMR::Numerics::Vector spot_price(stock_dim,0.0);
> FMR::Numerics::Vector start_price(stock_dim,0.0);
>
> FMR::Numerics::Vector result_vol(stock_dim,0.0);
> FMR::Numerics::Vector reducted_vol(stock_dim,0.0);
>
> mtl::copy(basket,spot_price);
>
> size_t dim_reduct=stock_dim;
> if (vol_dim != 0)
> {
> dim_reduct = vol_dim;
> }
>
> FMR::Numerics::Matrix reducted_matrix(stock_dim,stock_dim);
>
> size_t rank = 0;
> err = FMR::Numerics::DimensionalReduction(correlation_matrix,dim_reduct,vol_thres,reducted_matrix,rank);
> if (err) return err;
> if (rank==0) return 0x092c;
> reducted_matrix.resize(stock_dim,rank);
> dim_reduct=rank;
> FMR::Numerics::Vector randnorm_vect(dim_reduct,0.0);
>
> double value=0.0, error=0.0, strike=0.0, asset=0.0;
> double drift =0.0, sig =0.0, deltat =0.0, cashflow =0.0, outstanding=0.0, tmp_cash=0.0;
> long old_time, old_time_sh;
>
>
> double geo_value=0.0;
> if (control_var == 0 || control_var == 3)
> geo_value=0.0;
> else
> {
> if (control_var == 1 || control_var == 2)
> {
> err = static_cast<OptPayoff*>(payoff)->control_variate(geo_value);
> if (err) return err;
> }
> }
>
> LegSpecs::Entry cf;
>
>
> Leg::const_iterator opt_leg = entry->leg.begin(Flavors::Observation);
> Leg::const_iterator opt_end = entry->leg.end();
>
> if (opt_leg!=opt_end)
> {
> cf = **opt_leg;
> for (;(*opt_leg)->time<=settl;)
> {
> err = payoff->calculate(&cf);
> if (err) return err;
>
> if (!entry->leg.next(1,Flavors::Observation,opt_leg)) break;
> }
> }
>
>
>
>
> Leg::const_iterator iter;
> if (!entry->leg.synchro_after(settl,Flavors::Observation| Flavors::Option,Cache::NPos,iter)) return 0x0892;
>
>
> size_t dimension=0;
> for(opt_leg=iter;entry->leg.end();)
> {
> ++dimension;
> if (!entry->leg.next(1,Flavors::Observation | Flavors::Option,opt_leg)) break;
> }
> dimension*=dim_reduct;
>
>
> FMR4000::Finance::Private::QuasiNormal quasi(dimension);
> std::vector<double> z(dimension,0.0);
>
> double randnorm=0.0;
> double disc=0.0;
> double sh_rate=0.0;
>
> mtl::add(start_drift,mtl::scaled(growth_rate,- 1),start_drift);
>
> mtl::ele_mult(volatility_vect, volatility_vect, start_vol);
> mtl::add(start_drift,mtl::scaled(start_vol, - 0.5),start_drift);
>
> for (size_t l=0;l<(size_t)maxloop;++l)
> {
> old_time = trd;
> old_time_sh = settl;
> mtl::copy(spot_price,start_price);
>
> quasi.next(z);
>
> std::vector<double>::const_iterator p = z.begin();
>
>
> for(opt_leg=iter;entry->leg.end();)
> {
> size_t i;
>
> deltat= ((*opt_leg)->time - old_time)/365.0;
>
>
> err = hcurve->discount(old_time_sh,(*opt_leg)->time,sh_rate);
> if (err) return err;
> sh_rate= -log(sh_rate)/deltat;
> for (i=0; i<stock_dim; ++i) { short_drift[i]=sh_rate;}
>
> mtl::add(start_drift,short_drift,short_drift);
> mtl::add(mtl::scaled(short_drift,deltat),zero,drift_vect);
>
>
>
> double sqr_deltat= sqrt(deltat);
> mtl::add(mtl::scaled(volatility_vect, sqr_deltat),zero,start_vol);
>
> for ( i=0; i<dim_reduct; ++i)
> {
> randnorm = *p;
> randnorm_vect[i]=randnorm;
> ++p;
> }
>
>
> mtl::mult(reducted_matrix, randnorm_vect, reducted_vol);
> mtl::ele_mult(reducted_vol, start_vol, result_vol);
>
>
> for ( i=0; i<stock_dim; ++i)
> {
> start_price[i]=log(start_price[i]);
> start_price[i]+=drift_vect[i]+result_vol[i];
> start_price[i]=exp(start_price[i]);
> }
>
> cf = **opt_leg;
>
> mtl::copy(start_price,basket);
> err = payoff->calculate(&cf);
> if (err) return err;
>
>
> if ((*opt_leg)->flavor & Flavors::Option)
> {
>
> cashflow = cf.cache[payoff_pos];
>
> err = hcurve->discount(settl,(*opt_leg)->time,disc);
> if (err) return err;
>
> outstanding = has_out ? cf.cache[out_pos] : 1.0;
>
>
>
>
> tmp_cash = (geo_value + cashflow) * disc;
>
> tmp_cash *= outstanding;
> }
>
>
> for ( i=0; i<stock_dim; ++i)
> { drift_vect[i]=start_vol[i]=short_drift[i]=0.0;}
>
> old_time = old_time_sh = (*opt_leg)->time;
> if (!entry->leg.next(1,Flavors::Observation | Flavors::Option,opt_leg)) break;
> }
>
>
> value += tmp_cash;
> error += tmp_cash*tmp_cash;
> }
>
> if (error - value*value/maxloop<1.e-12)
> error=0.0;
> else
> {error = sqrt((error - value*value/maxloop)/(maxloop-1.0)) / sqrt(maxloop);}
>
> value= (value / maxloop);
>
>
> typedef Service::AccessObj<RtData,Service::ReadWrite> ReportAT;
> ReportAT::Handle hreport = ReportAT::get_handle(pxreport);
> if (hreport)
> {
> double old_value=0.0, option_value=0.0, old_error=0.0, option_error=0.0;
> hreport->get_value(underlying+"Price",option_value);
> hreport->get_value(underlying+"Error",option_error);
> hreport->get_value("Option.Price",old_value);
> hreport->get_value("Option.Error",old_error);
> option_value += value;
> old_value += value;
> option_error = sqrt(option_error*option_error + error*error);
> old_error = sqrt(old_error*old_error + error*error);
> err = hreport->update_value(underlying+"Price",option_value,"~volatile");
> if (err) return err;
> err = hreport->update_value(underlying+"Error",option_error,"~volatile");
> if (err) return err;
> err = hreport->update_value("Option.Price",old_value);
> if (err) return err;
> err = hreport->update_value("Option.Error",old_error);
> if (err) return err;
> }
> return err;
>}

Actions: View

Attachments on bug 228033: 147787