#13 "/usr/include/sys/feature_tests.h"
#pragma ident "@(#)feature_tests.h	1.17	97/12/04 SMI" 
#9 "/usr/include/sys/isa_defs.h"
#pragma ident "@(#)isa_defs.h	1.15	97/11/22 SMI" 
#142
extern "C" { 
#323
} 
#18 "/usr/include/sys/feature_tests.h"
extern "C" { 
#175
} 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/stddef.h"
#pragma ident "@(#)stddef.h	1.6  02/01/99 C++5.0" 



extern "C" { 
#28
namespace std { 
#35
typedef int ptrdiff_t ; 
#44
typedef unsigned int size_t ; 



} 

} 
#61
using std :: ptrdiff_t ; 
using std :: size_t ; 
#161 "/opt/SUNWspro/SC5.0/include/CC/rw/stddefs.h"
const size_t _RWSTD_NPOS = ~ ( size_t ) 0 ; 
#170
class _RWSTDMutex ; 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/stdarg.h"
#pragma ident "@(#)stdarg.h	1.6  02/01/99 C++5.0" 




typedef void * __va_list ; 


extern "C" { 



typedef __va_list va_list ; 
#76
extern void va_end ( va_list ) ; 





namespace std { 
#92
typedef :: __va_list va_list ; 


} 

} 
#107
using std :: va_list ; 
#117
extern "C" { 
#132
} 
#39 "/opt/SUNWspro/SC5.0/include/CC/rw/rwstderr.h"
namespace __rwstd { 




class except_msg_string 
{ 
public : 
except_msg_string ( const char * ... ) ; 
except_msg_string ( unsigned int ... ) ; 
const char * msgstr ( ) const { return __msg ; } 
private : 
except_msg_string ( const except_msg_string & ) ; 
except_msg_string & operator = ( const except_msg_string & ) ; 
char __msg [ 240 ] ; 
} ; 


} 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/string.h"
#pragma ident "@(#)string.h	1.7  05/08/99 C++5.0" 
#25
namespace std { 
#36
extern "C" { 

void * memcpy ( void * , const void * , size_t ) ; 
void * memmove ( void * , const void * , size_t ) ; 
char * strcpy ( char * , const char * ) ; 
char * strncpy ( char * , const char * , size_t ) ; 
char * strcat ( char * , const char * ) ; 
char * strncat ( char * , const char * , size_t ) ; 
int memcmp ( const void * , const void * , size_t ) ; 
int strcmp ( const char * , const char * ) ; 
int strcoll ( const char * , const char * ) ; 
int strncmp ( const char * , const char * , size_t ) ; 
size_t strxfrm ( char * , const char * , size_t ) ; 
size_t strcspn ( const char * , const char * ) ; 
size_t strspn ( const char * , const char * ) ; 
char * strtok ( char * , const char * ) ; 
void * memset ( void * , int , size_t ) ; 
char * strerror ( int ) ; 
size_t strlen ( const char * ) ; 

} 




extern "C" const char * strchr ( const char * , int ) ; 
inline char * strchr ( char * c , int i ) { 
return ( char * ) strchr ( ( const char * ) c , i ) ; 
} 
extern "C" const char * strpbrk ( const char * , const char * ) ; 
inline char * strpbrk ( char * c , const char * d ) { 
return ( char * ) strpbrk ( ( const char * ) c , d ) ; 
} 
extern "C" const char * strrchr ( const char * , int ) ; 
inline char * strrchr ( char * c , int i ) { 
return ( char * ) strrchr ( ( const char * ) c , i ) ; 
} 
extern "C" const char * strstr ( const char * , const char * ) ; 
inline char * strstr ( char * c , const char * d ) { 
return ( char * ) strstr ( ( const char * ) c , d ) ; 
} 
extern "C" const void * memchr ( const void * , int , size_t ) ; 


inline void * memchr ( void * c , int i , size_t d ) { 
return ( void * ) memchr ( ( const void * ) c , i , d ) ; 
} 


} 
#95
using std :: size_t ; 
using std :: memchr ; 
using std :: memcmp ; 
using std :: memcpy ; 
using std :: memmove ; 
using std :: memset ; 
using std :: strcat ; 
using std :: strchr ; 
using std :: strcmp ; 
using std :: strcoll ; 
using std :: strcpy ; 
using std :: strcspn ; 
using std :: strerror ; 
using std :: strlen ; 
using std :: strncat ; 
using std :: strncmp ; 
using std :: strncpy ; 
using std :: strpbrk ; 
using std :: strrchr ; 
using std :: strspn ; 
using std :: strstr ; 
using std :: strtok ; 
using std :: strxfrm ; 
#140
extern "C" { 
#149
extern void * memccpy ( void * , const void * , int , size_t ) ; 
#156
extern char * strsignal ( int ) ; 




extern int ffs ( int ) ; 


extern int strcasecmp ( const char * , const char * ) ; 
extern int strncasecmp ( const char * , const char * , size_t ) ; 





extern char * strdup ( const char * ) ; 


} 
#13 "/opt/SUNWspro/SC5.0/include/CC/std/ctype.h"
#pragma ident "@(#)ctype.h	1.6  02/01/99 C++5.0" 



extern "C" { 
#45
extern unsigned char __ctype [ ] ; 
extern unsigned int * __ctype_mask ; 





extern int * __trans_upper ; 
extern int * __trans_lower ; 





namespace std { 

extern int isalnum ( int ) ; 
extern int isalpha ( int ) ; 
extern int iscntrl ( int ) ; 
extern int isdigit ( int ) ; 
extern int isgraph ( int ) ; 
extern int islower ( int ) ; 
extern int isprint ( int ) ; 
extern int ispunct ( int ) ; 
extern int isspace ( int ) ; 
extern int isupper ( int ) ; 
extern int isxdigit ( int ) ; 
extern int tolower ( int ) ; 
extern int toupper ( int ) ; 

} 

} 
#88
using std :: isalnum ; 
using std :: isalpha ; 
using std :: iscntrl ; 
using std :: isdigit ; 
using std :: isgraph ; 
using std :: islower ; 
using std :: isprint ; 
using std :: ispunct ; 
using std :: isspace ; 
using std :: isupper ; 
using std :: isxdigit ; 
using std :: tolower ; 
using std :: toupper ; 
#111
extern "C" { 
#118
extern int isascii ( int ) ; 
extern int toascii ( int ) ; 
extern int _tolower ( int ) ; 
extern int _toupper ( int ) ; 
#182
} 
#45 "/opt/SUNWspro/SC5.0/include/CC/./string"
namespace std { 


class mbstate_t ; 


} 




using std :: mbstate_t ; 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/wchar.h"
#pragma ident "@(#)wchar.h	1.12  02/04/99 C++5.0" 
#9 "/usr/include/stdio_tag.h"
#pragma ident "@(#)stdio_tag.h	1.3	98/04/20 SMI" 


extern "C" { 
#21
typedef struct __FILE __FILE ; 



} 
#9 "/usr/include/wchar_impl.h"
#pragma ident "@(#)wchar_impl.h	1.2	98/02/27 SMI" 




extern "C" { 
#28
} 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/time.h"
#pragma ident "@(#)time.h	1.8  02/01/99 C++5.0" 
#16 "/usr/include/sys/types.h"
#pragma ident "@(#)types.h	1.63	98/04/28 SMI" 
#16 "/usr/include/sys/machtypes.h"
#pragma ident "@(#)machtypes.h	1.12	96/08/01 SMI" 




extern "C" { 
#33
typedef struct _physadr_t { int r [ 1 ] ; } * physadr_t ; 

typedef struct _label_t { long val [ 2 ] ; } label_t ; 



typedef unsigned char lock_t ; 


} 
#9 "/usr/include/sys/int_types.h"
#pragma ident "@(#)int_types.h	1.6	97/08/20 SMI" 
#45
extern "C" { 
#62
typedef char int8_t ; 





typedef short int16_t ; 
typedef int int32_t ; 




typedef long long int64_t ; 



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




typedef unsigned long long uint64_t ; 
#94
typedef int64_t intmax_t ; 
typedef uint64_t uintmax_t ; 
#110
typedef int intptr_t ; 
typedef unsigned int uintptr_t ; 
#119
typedef char int_least8_t ; 





typedef short int_least16_t ; 
typedef int int_least32_t ; 




typedef long long int_least64_t ; 



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




typedef unsigned long long uint_least64_t ; 




} 
#44 "/usr/include/sys/types.h"
extern "C" { 
#53
typedef long long longlong_t ; 
typedef unsigned long long u_longlong_t ; 
#76
typedef long t_scalar_t ; 
typedef unsigned long t_uscalar_t ; 





typedef unsigned char uchar_t ; 
typedef unsigned short ushort_t ; 
typedef unsigned int uint_t ; 
typedef unsigned long ulong_t ; 

typedef char * caddr_t ; 
typedef long daddr_t ; 
typedef short cnt_t ; 


typedef ulong_t paddr_t ; 
#101
typedef int ptrdiff_t ; 
#108
typedef ulong_t pfn_t ; 
typedef ulong_t pgcnt_t ; 
typedef long spgcnt_t ; 

typedef uchar_t use_t ; 
typedef short sysid_t ; 
typedef short index_t ; 
typedef void * timeout_id_t ; 
typedef void * bufcall_id_t ; 
#130
typedef long off_t ; 
#139
typedef longlong_t off64_t ; 
#146
typedef ulong_t ino_t ; 
typedef long blkcnt_t ; 
typedef ulong_t fsblkcnt_t ; 
typedef ulong_t fsfilcnt_t ; 
#164
typedef u_longlong_t ino64_t ; 
typedef longlong_t blkcnt64_t ; 
typedef u_longlong_t fsblkcnt64_t ; 
typedef u_longlong_t fsfilcnt64_t ; 
#174
typedef long blksize_t ; 





typedef enum { B_FALSE , B_TRUE } boolean_t ; 
#191
typedef int64_t pad64_t ; 
typedef uint64_t upad64_t ; 
#204
typedef longlong_t offset_t ; 
typedef u_longlong_t u_offset_t ; 
typedef u_longlong_t len_t ; 
typedef longlong_t diskaddr_t ; 
#225
typedef union { 
offset_t _f ; 
struct { 
int32_t _u ; 
int32_t _l ; 
} _p ; 
} lloff_t ; 
#245
typedef union { 
diskaddr_t _f ; 
struct { 
int32_t _u ; 
int32_t _l ; 
} _p ; 
} lldaddr_t ; 


typedef uint_t k_fltset_t ; 
#270
typedef long id_t ; 
#277
typedef uint_t useconds_t ; 



typedef long suseconds_t ; 
#291
typedef ulong_t major_t ; 
typedef ulong_t minor_t ; 





typedef short pri_t ; 
#311
typedef ushort_t o_mode_t ; 
typedef short o_dev_t ; 
typedef ushort_t o_uid_t ; 
typedef o_uid_t o_gid_t ; 
typedef short o_nlink_t ; 
typedef short o_pid_t ; 
typedef ushort_t o_ino_t ; 





typedef int key_t ; 



typedef ulong_t mode_t ; 
#335
typedef long uid_t ; 



typedef uid_t gid_t ; 
#346
typedef unsigned int pthread_t ; 
typedef unsigned int pthread_key_t ; 

typedef struct _pthread_mutex { 
struct { 
uint8_t __pthread_mutex_flag [ 4 ] ; 
uint32_t __pthread_mutex_type ; 
} __pthread_mutex_flags ; 
union { 
struct { 
uint8_t __pthread_mutex_pad [ 8 ] ; 
} __pthread_mutex_lock64 ; 
upad64_t __pthread_mutex_owner64 ; 
} __pthread_mutex_lock ; 
upad64_t __pthread_mutex_data ; 
} pthread_mutex_t ; 

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




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




typedef struct _pthread_attr { 
void * __pthread_attrp ; 
} pthread_attr_t ; 





typedef struct _pthread_mutexattr { 
void * __pthread_mutexattrp ; 
} pthread_mutexattr_t ; 





typedef struct _pthread_condattr { 
void * __pthread_condattrp ; 
} pthread_condattr_t ; 




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





typedef struct _pthread_rwlockattr { 
void * __pthread_rwlockattrp ; 
} pthread_rwlockattr_t ; 

typedef ulong_t dev_t ; 





typedef ulong_t nlink_t ; 
typedef long pid_t ; 
#436
typedef uint_t size_t ; 
#445
typedef int ssize_t ; 





typedef long time_t ; 




typedef long clock_t ; 




typedef int clockid_t ; 




typedef int timer_t ; 
#473
typedef unsigned char unchar ; 
typedef unsigned short ushort ; 
typedef unsigned int uint ; 
typedef unsigned long ulong ; 
#527
typedef unsigned char u_char ; 
typedef unsigned short u_short ; 
typedef unsigned int u_int ; 
typedef unsigned long u_long ; 
typedef struct _quad { int val [ 2 ] ; } quad_t ; 
typedef quad_t quad ; 
#12 "/usr/include/sys/select.h"
#pragma ident "@(#)select.h	1.16	98/04/27 SMI" 
#22 "/usr/include/sys/time.h"
#pragma ident "@(#)time.h	2.62	98/02/04 SMI" 
#32
extern "C" { 
#49
struct timeval { 
time_t tv_sec ; 
suseconds_t tv_usec ; 
} ; 
#82
struct timezone { 
int tz_minuteswest ; 
int tz_dsttime ; 
} ; 





} 
#104
extern "C" { 
#155
struct itimerval { 
struct timeval it_interval ; 
struct timeval it_value ; 
} ; 
#203
typedef longlong_t hrtime_t ; 
#315
int adjtime ( struct timeval * , struct timeval * ) ; 
#326
int getitimer ( int , struct itimerval * ) ; 
int utimes ( const char * , const struct timeval * ) ; 



int setitimer ( int , struct itimerval * , struct itimerval * ) ; 
#364
int settimeofday ( struct timeval * , void * ) ; 

hrtime_t gethrtime ( void ) ; 
hrtime_t gethrvtime ( void ) ; 
#384
int gettimeofday ( struct timeval * , void * ) ; 
#424
} 
#21 "/usr/include/sys/select.h"
extern "C" { 
#45
typedef long fd_mask ; 

typedef long fds_mask ; 
#73
typedef struct fd_set { 



long fds_bits [ ( ( ( 1024 ) + ( ( ( sizeof ( fds_mask ) * 8 ) ) - 1 ) ) / ( ( sizeof ( fds_mask ) * 8 ) ) ) ] ; 
} fd_set ; 
#97
extern int select ( int , fd_set * , fd_set * , fd_set * , struct timeval * ) ; 
#104
} 
#556 "/usr/include/sys/types.h"
} 
#15 "/usr/include/sys/time_impl.h"
#pragma ident "@(#)time_impl.h	1.3	98/02/13 SMI" 




extern "C" { 
#36
typedef struct timespec { 
time_t tv_sec ; 
long tv_nsec ; 
} timespec_t ; 
#60
typedef struct timespec timestruc_t ; 
#79
typedef struct itimerspec { 
struct timespec it_interval ; 
struct timespec it_value ; 
} itimerspec_t ; 
#130
} 
#31 "/opt/SUNWspro/SC5.0/include/CC/std/time.h"
extern "C" { 
#46
namespace std { 
#59
typedef long clock_t ; 




typedef long time_t ; 




typedef int clockid_t ; 




typedef int timer_t ; 




struct tm { 
int tm_sec ; 
int tm_min ; 
int tm_hour ; 
int tm_mday ; 
int tm_mon ; 
int tm_year ; 
int tm_wday ; 
int tm_yday ; 
int tm_isdst ; 
} ; 


extern clock_t clock ( void ) ; 
extern double difftime ( time_t , time_t ) ; 
extern time_t mktime ( struct tm * ) ; 
extern time_t time ( time_t * ) ; 
extern char * asctime ( const struct tm * ) ; 
extern char * ctime ( const time_t * ) ; 
extern struct tm * gmtime ( const time_t * ) ; 
extern struct tm * localtime ( const time_t * ) ; 
extern size_t strftime ( char * , size_t , const char * , const struct tm * ) ; 

} 

} 
#115
using std :: size_t ; 


using std :: clock_t ; 


using std :: time_t ; 

using std :: asctime ; 
using std :: clock ; 
using std :: ctime ; 
using std :: difftime ; 
using std :: gmtime ; 
using std :: localtime ; 
using std :: mktime ; 
using std :: strftime ; 
using std :: time ; 
using std :: tm ; 

#pragma override_linkname 
typedef :: tm tm ; 
#pragma no_override_linkname 
#145
extern "C" { 
#158
extern char * strptime ( const char * , const char * , struct tm * ) ; 
#177
union sigval { 
int sival_int ; 
void * sival_ptr ; 
} ; 




struct sigevent { 
int sigev_notify ; 
int sigev_signo ; 
union sigval sigev_value ; 
void ( * sigev_notify_function ) ( union sigval ) ; 
pthread_attr_t * sigev_notify_attributes ; 
int __sigev_pad2 ; 
} ; 
#201
extern int clock_getres ( clockid_t , struct timespec * ) ; 
extern int clock_gettime ( clockid_t , struct timespec * ) ; 
extern int clock_settime ( clockid_t , const struct timespec * ) ; 

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





extern void tzset ( void ) ; 

extern char * tzname [ 2 ] ; 


extern long _sysconf ( int ) ; 
#234
extern long timezone ; 
extern int daylight ; 





extern int cftime ( char * , char * , const time_t * ) ; 
extern int ascftime ( char * , const char * , const struct tm * ) ; 
extern long altzone ; 




extern struct tm * getdate ( const char * ) ; 
#255
extern int getdate_err ; 
#327
} 
#35 "/opt/SUNWspro/SC5.0/include/CC/std/wchar.h"
extern "C" { 
#67
namespace std { 
#74
typedef long wint_t ; 





typedef int wctype_t ; 
#104
extern int iswalpha ( wint_t ) ; 
extern int iswupper ( wint_t ) ; 
extern int iswlower ( wint_t ) ; 
extern int iswdigit ( wint_t ) ; 
extern int iswxdigit ( wint_t ) ; 
extern int iswalnum ( wint_t ) ; 
extern int iswspace ( wint_t ) ; 
extern int iswpunct ( wint_t ) ; 
extern int iswprint ( wint_t ) ; 
extern int iswgraph ( wint_t ) ; 
extern int iswcntrl ( wint_t ) ; 
extern int iswctype ( wint_t , wctype_t ) ; 
extern wint_t towlower ( wint_t ) ; 
extern wint_t towupper ( wint_t ) ; 
#129
extern wint_t fgetwc ( __FILE * ) ; 
extern wchar_t * fgetws ( wchar_t * , int , __FILE * ) ; 
extern wint_t fputwc ( wint_t , __FILE * ) ; 
extern int fputws ( const wchar_t * , __FILE * ) ; 
extern wint_t ungetwc ( wint_t , __FILE * ) ; 
extern wint_t getwc ( __FILE * ) ; 
extern wint_t getwchar ( void ) ; 
extern wint_t putwc ( wint_t , __FILE * ) ; 




extern wint_t putwchar ( wint_t ) ; 

extern double wcstod ( const wchar_t * , wchar_t * * ) ; 
extern long wcstol ( const wchar_t * , wchar_t * * , int ) ; 
extern unsigned long wcstoul ( const wchar_t * , wchar_t * * , int ) ; 
extern wchar_t * wcscat ( wchar_t * , const wchar_t * ) ; 
extern wchar_t * wcschr ( const wchar_t * , wchar_t ) ; 
extern int wcscmp ( const wchar_t * , const wchar_t * ) ; 
extern int wcscoll ( const wchar_t * , const wchar_t * ) ; 
extern wchar_t * wcscpy ( wchar_t * , const wchar_t * ) ; 
extern size_t wcscspn ( const wchar_t * , const wchar_t * ) ; 
extern size_t wcslen ( const wchar_t * ) ; 
extern wchar_t * wcsncat ( wchar_t * , const wchar_t * , size_t ) ; 
extern int wcsncmp ( const wchar_t * , const wchar_t * , size_t ) ; 
extern wchar_t * wcsncpy ( wchar_t * , const wchar_t * , size_t ) ; 
extern wchar_t * wcspbrk ( const wchar_t * , const wchar_t * ) ; 
extern wchar_t * wcsrchr ( const wchar_t * , wchar_t ) ; 
extern size_t wcsspn ( const wchar_t * , const wchar_t * ) ; 

extern wchar_t * wcswcs ( const wchar_t * , const wchar_t * ) ; 
extern int wcswidth ( const wchar_t * , size_t ) ; 
extern size_t wcsxfrm ( wchar_t * , const wchar_t * , size_t ) ; 
extern int wcwidth ( const wchar_t ) ; 

extern wctype_t wctype ( const char * ) ; 
#173
extern wchar_t * wcstok ( wchar_t * , const wchar_t * , wchar_t * * ) ; 
extern size_t wcsftime ( wchar_t * , size_t , const wchar_t * , const struct tm * ) ; 
#pragma redefine_extname wcstok __wcstok_xpg5 
#pragma redefine_extname wcsftime __wcsftime_xpg5 
#191
extern wint_t btowc ( int ) ; 
extern int fwprintf ( __FILE * , const wchar_t * , ... ) ; 
extern int fwscanf ( __FILE * , const wchar_t * , ... ) ; 
extern int fwide ( __FILE * , int ) ; 
extern int mbsinit ( const mbstate_t * ) ; 
extern size_t mbrlen ( const char * , size_t , mbstate_t * ) ; 
extern size_t mbrtowc ( wchar_t * , const char * , size_t , mbstate_t * ) ; 
extern size_t mbsrtowcs ( wchar_t * , const char * * , size_t , mbstate_t * ) ; 
extern int swprintf ( wchar_t * , size_t , const wchar_t * , ... ) ; 
extern int swscanf ( const wchar_t * , const wchar_t * , ... ) ; 
extern int vfwprintf ( __FILE * , const wchar_t * , __va_list ) ; 
extern int vwprintf ( const wchar_t * , __va_list ) ; 
extern int vswprintf ( wchar_t * , size_t , const wchar_t * , __va_list ) ; 
extern size_t wcrtomb ( char * , wchar_t , mbstate_t * ) ; 
extern size_t wcsrtombs ( char * , const wchar_t * * , size_t , mbstate_t * ) ; 
extern wchar_t * wcsstr ( const wchar_t * , const wchar_t * ) ; 
extern int wctob ( wint_t ) ; 
extern wchar_t * wmemchr ( const wchar_t * , wchar_t , size_t ) ; 
extern int wmemcmp ( const wchar_t * , const wchar_t * , size_t ) ; 
extern wchar_t * wmemcpy ( wchar_t * , const wchar_t * , size_t ) ; 
extern wchar_t * wmemmove ( wchar_t * , const wchar_t * , size_t ) ; 
extern wchar_t * wmemset ( wchar_t * , wchar_t , size_t ) ; 
extern int wprintf ( const wchar_t * , ... ) ; 
extern int wscanf ( const wchar_t * , ... ) ; 


} 
#228
#pragma redefine_extname fgetwc __fgetwc_xpg5 
#pragma redefine_extname getwc __getwc_xpg5 
#pragma redefine_extname getwchar __getwchar_xpg5 
#pragma redefine_extname fputwc __fputwc_xpg5 
#pragma redefine_extname putwc __putwc_xpg5 
#pragma redefine_extname putwchar __putwchar_xpg5 
#pragma redefine_extname fgetws __fgetws_xpg5 
#pragma redefine_extname fputws __fputws_xpg5 
#pragma redefine_extname ungetwc __ungetwc_xpg5 
#260
} 
#270
using std :: wint_t ; 
using std :: size_t ; 
using std :: tm ; 

using std :: fgetwc ; 
using std :: fgetws ; 
using std :: fputwc ; 
using std :: fputws ; 
using std :: getwc ; 
using std :: putwc ; 
using std :: putwchar ; 
using std :: ungetwc ; 

using std :: wcstod ; 
using std :: wcstol ; 
using std :: wcscpy ; 
using std :: wcsncpy ; 
using std :: wcscat ; 
using std :: wcsncat ; 
using std :: wcscmp ; 
using std :: wcscoll ; 
using std :: wcsncmp ; 
using std :: wcsxfrm ; 
using std :: wcschr ; 
using std :: wcscspn ; 
using std :: wcspbrk ; 
using std :: wcsrchr ; 
using std :: wcsspn ; 
using std :: wcslen ; 


using std :: iswalpha ; 
using std :: iswupper ; 
using std :: iswlower ; 
using std :: iswdigit ; 
using std :: iswxdigit ; 
using std :: iswalnum ; 
using std :: iswspace ; 
using std :: iswpunct ; 
using std :: iswprint ; 
using std :: iswgraph ; 
using std :: iswcntrl ; 
using std :: iswctype ; 
using std :: towlower ; 
using std :: towupper ; 


using std :: mbstate_t ; 
using std :: getwchar ; 
using std :: wcstok ; 
using std :: wcsftime ; 
using std :: wmemchr ; 
using std :: wmemcmp ; 
using std :: wmemcpy ; 
using std :: wmemmove ; 
using std :: wmemset ; 
using std :: wcsstr ; 
using std :: fwide ; 
using std :: fwprintf ; 
using std :: fwscanf ; 
using std :: vfwprintf ; 
using std :: vwprintf ; 
using std :: vswprintf ; 
using std :: wprintf ; 
using std :: swscanf ; 
using std :: wscanf ; 
using std :: swprintf ; 
using std :: btowc ; 
using std :: wctob ; 
using std :: mbsinit ; 
using std :: mbrlen ; 
using std :: mbrtowc ; 
using std :: mbsrtowcs ; 
using std :: wcrtomb ; 
using std :: wcsrtombs ; 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/wctype.h"
#pragma ident "@(#)wctype.h	1.8  02/03/99 C++5.0" 
#21
extern "C" { 
#56
extern unsigned _iswctype ( wchar_t , int ) ; 
extern wchar_t _trwctype ( wchar_t , int ) ; 





namespace std { 
#70
typedef long wint_t ; 





typedef int wctype_t ; 



typedef unsigned int wctrans_t ; 
#91
extern wctrans_t wctrans ( const char * ) ; 
extern wint_t towctrans ( wint_t , wctrans_t ) ; 


extern int iswalpha ( wint_t ) ; 
extern int iswupper ( wint_t ) ; 
extern int iswlower ( wint_t ) ; 
extern int iswdigit ( wint_t ) ; 
extern int iswxdigit ( wint_t ) ; 
extern int iswalnum ( wint_t ) ; 
extern int iswspace ( wint_t ) ; 
extern int iswpunct ( wint_t ) ; 
extern int iswprint ( wint_t ) ; 
extern int iswgraph ( wint_t ) ; 
extern int iswcntrl ( wint_t ) ; 

extern wint_t towlower ( wint_t ) ; 
extern wint_t towupper ( wint_t ) ; 
extern int iswctype ( wint_t , wctype_t ) ; 
extern wctype_t wctype ( const char * ) ; 

} 

} 
#124
using std :: wint_t ; 

using std :: wctrans_t ; 
using std :: wctrans ; 
using std :: towctrans ; 

using std :: wctype_t ; 
using std :: iswctype ; 
using std :: wctype ; 
using std :: iswalnum ; 
using std :: iswalpha ; 
using std :: iswcntrl ; 
using std :: iswdigit ; 
using std :: iswgraph ; 
using std :: iswlower ; 
using std :: iswprint ; 
using std :: iswpunct ; 
using std :: iswspace ; 
using std :: iswupper ; 
using std :: iswxdigit ; 

using std :: towlower ; 
using std :: towupper ; 
#157
extern "C" { 
#170
struct _wctype { 
wchar_t tmin ; 
wchar_t tmax ; 
unsigned char * index ; 
unsigned int * type ; 
wchar_t cmin ; 
wchar_t cmax ; 
wchar_t * code ; 
} ; 





extern int iswalpha ( wint_t c ) ; 
extern int iswupper ( wint_t c ) ; 
extern int iswlower ( wint_t c ) ; 
extern int iswdigit ( wint_t c ) ; 
extern int iswxdigit ( wint_t c ) ; 
extern int iswalnum ( wint_t c ) ; 
extern int iswspace ( wint_t c ) ; 
extern int iswpunct ( wint_t c ) ; 
extern int iswprint ( wint_t c ) ; 
extern int iswgraph ( wint_t c ) ; 
extern int iswcntrl ( wint_t c ) ; 
#201
extern int isphonogram ( wint_t ) ; 
extern int isideogram ( wint_t ) ; 
extern int isenglish ( wint_t ) ; 
extern int isnumber ( wint_t ) ; 
extern int isspecial ( wint_t ) ; 
#217
} 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/stdlib.h"
#pragma ident "@(#)stdlib.h	1.7  02/03/99 C++5.0" 
#75
extern "C" unsigned char __ctype [ ] ; 
#84
namespace std { 

typedef struct { 
int quot ; 
int rem ; 
} div_t ; 

typedef struct { 
long quot ; 
long rem ; 
} ldiv_t ; 


typedef struct { 
long long quot ; 
long long rem ; 
} lldiv_t ; 
#117
typedef long uid_t ; 



extern "C" { 
extern double atof ( const char * ) ; 
extern int atoi ( const char * ) ; 
extern long int atol ( const char * ) ; 
extern double strtod ( const char * , char * * ) ; 
extern long int strtol ( const char * , char * * , int ) ; 
extern unsigned long int strtoul ( const char * , char * * , int ) ; 
extern int rand ( void ) ; 
extern void srand ( unsigned int ) ; 
extern void * calloc ( size_t , size_t ) ; 
extern void free ( void * ) ; 
extern void * malloc ( size_t ) ; 
extern void * realloc ( void * , size_t ) ; 
extern void abort ( void ) ; 
extern int atexit ( void ( * ) ( void ) ) ; 
extern void exit ( int ) ; 
extern void _exithandle ( void ) ; 
extern char * getenv ( const char * ) ; 
extern int system ( const char * ) ; 
extern void * bsearch ( const void * , const void * , size_t , size_t , 
int ( * ) ( const void * , const void * ) ) ; 
extern void qsort ( void * , size_t , size_t , 
int ( * ) ( const void * , const void * ) ) ; 
extern int abs ( int ) ; 
extern div_t div ( int , int ) ; 
extern long int labs ( long ) ; 
extern ldiv_t ldiv ( long , long ) ; 
extern int mbtowc ( wchar_t * , const char * , size_t ) ; 
extern int mblen ( const char * , size_t ) ; 
extern int wctomb ( char * , wchar_t ) ; 
extern size_t mbstowcs ( wchar_t * , const char * , size_t ) ; 
extern size_t wcstombs ( char * , const wchar_t * , size_t ) ; 
} 


extern long abs ( long ) ; 
extern ldiv_t div ( long , long ) ; 

} 
#169
using std :: div_t ; 
using std :: ldiv_t ; 
using std :: lldiv_t ; 
using std :: size_t ; 
using std :: abort ; 
using std :: abs ; 
using std :: atexit ; 
using std :: atof ; 
using std :: atoi ; 
using std :: atol ; 
using std :: bsearch ; 
using std :: calloc ; 
using std :: div ; 
using std :: exit ; 
using std :: free ; 
using std :: getenv ; 
using std :: labs ; 
using std :: ldiv ; 
using std :: malloc ; 
using std :: mblen ; 
using std :: mbstowcs ; 
using std :: mbtowc ; 
using std :: qsort ; 
using std :: rand ; 
using std :: realloc ; 
using std :: srand ; 
using std :: strtod ; 
using std :: strtol ; 
using std :: strtoul ; 
using std :: system ; 
using std :: wcstombs ; 
using std :: wctomb ; 

#pragma override_linkname 
typedef div_t __div_t ; 
typedef ldiv_t __ldiv_t ; 
typedef lldiv_t __lldiv_t ; 
#pragma no_override_linkname 
#247
extern "C" { 
#258
extern double drand48 ( void ) ; 
extern double erand48 ( unsigned short * ) ; 
extern long jrand48 ( unsigned short * ) ; 
extern void lcong48 ( unsigned short * ) ; 
extern long lrand48 ( void ) ; 
extern long mrand48 ( void ) ; 
extern long nrand48 ( unsigned short * ) ; 
extern unsigned short * seed48 ( unsigned short * ) ; 
extern void srand48 ( long ) ; 




extern int putenv ( char * ) ; 


extern void setkey ( const char * ) ; 
#281
extern void swab ( const char * , char * , int ) ; 





extern int mkstemp ( char * ) ; 


extern int mkstemp64 ( char * ) ; 
#298
extern long a64l ( const char * ) ; 
extern char * ecvt ( double , int , int * , int * ) ; 
extern char * fcvt ( double , int , int * , int * ) ; 
extern char * gcvt ( double , int , char * ) ; 
extern int getsubopt ( char * * , char * const * , char * * ) ; 
extern int grantpt ( int ) ; 
extern char * initstate ( unsigned , char * , size_t ) ; 
extern char * l64a ( long ) ; 
extern char * mktemp ( char * ) ; 
extern char * ptsname ( int ) ; 
extern long random ( void ) ; 
extern char * realpath ( const char * , char * ) ; 
extern char * setstate ( const char * ) ; 
extern void srandom ( unsigned ) ; 
extern int ttyslot ( void ) ; 
extern int unlockpt ( int ) ; 
extern void * valloc ( size_t ) ; 




extern int dup2 ( int , int ) ; 
extern char * qecvt ( long double , int , int * , int * ) ; 
extern char * qfcvt ( long double , int , int * , int * ) ; 
extern char * qgcvt ( long double , int , char * ) ; 
extern char * getcwd ( char * , size_t ) ; 

extern const char * getexecname ( void ) ; 
extern char * getpassphrase ( const char * ) ; 

extern char * getlogin ( void ) ; 
extern int getopt ( int , char * const * , const char * ) ; 
extern char * optarg ; 
extern int optind , opterr , optopt ; 
extern char * getpass ( const char * ) ; 
extern int getpw ( uid_t , char * ) ; 
extern int isatty ( int ) ; 
extern void * memalign ( size_t , size_t ) ; 
extern char * ttyname ( int ) ; 

extern long long atoll ( const char * ) ; 
extern long long llabs ( long long ) ; 
extern lldiv_t lldiv ( long long , long long ) ; 
extern char * lltostr ( long long , char * ) ; 
extern long long strtoll ( const char * , char * * , int ) ; 
extern unsigned long long strtoull ( const char * , char * * , int ) ; 
extern char * ulltostr ( unsigned long long , char * ) ; 



} 
#16 "/usr/include/limits.h"
#pragma ident "@(#)limits.h	1.48	98/07/20 SMI" 
#9 "/usr/include/sys/int_limits.h"
#pragma ident "@(#)int_limits.h	1.5	98/01/06 SMI" 
#47
extern "C" { 
#162
} 
#35 "/usr/include/limits.h"
extern "C" { 
#307
} 
#14 "/opt/SUNWspro/SC5.0/include/CC/./exception"
namespace std { 

class exception { 
public : 
exception ( ) throw ( ) { } 
exception ( const exception & ) throw ( ) { } 
exception & operator = ( const exception & ) throw ( ) { return * this ; } 
virtual ~ exception ( ) throw ( ) { } 
virtual const char * what ( ) const throw ( ) ; 
} ; 

class bad_exception : public exception { 
public : 
bad_exception ( ) throw ( ) { } 
bad_exception ( const bad_exception & ) throw ( ) { } 
bad_exception & operator = ( const bad_exception & ) throw ( ) { return * this ; } 
~ bad_exception ( ) throw ( ) { } 
const char * what ( ) const throw ( ) ; 
} ; 



typedef void ( * unexpected_handler ) ( ) ; 
unexpected_handler set_unexpected ( unexpected_handler ) throw ( ) ; 
void unexpected ( ) ; 



typedef void ( * terminate_handler ) ( ) ; 
terminate_handler set_terminate ( terminate_handler ) throw ( ) ; 
void terminate ( ) ; 

bool uncaught_exception ( ) throw ( ) ; 
} 
#16 "/opt/SUNWspro/SC5.0/include/CC/./new"
namespace std { 

class bad_alloc : public exception { 
public : 
bad_alloc ( ) throw ( ) { } 
bad_alloc ( const bad_alloc & ) throw ( ) { } 
bad_alloc & operator = ( const bad_alloc & ) throw ( ) { return * this ; } 
~ bad_alloc ( ) throw ( ) { } 
const char * what ( ) const throw ( ) ; 
} ; 
struct nothrow_t { } ; 
extern const nothrow_t nothrow ; 
typedef void ( * new_handler ) ( ) ; 
extern new_handler set_new_handler ( new_handler new_p ) throw ( ) ; 
} 

void * operator new ( size_t ) throw ( std :: bad_alloc ) ; 
void * operator new ( size_t , const std :: nothrow_t & ) throw ( ) ; 
void operator delete ( void * ) throw ( ) ; 
void operator delete ( void * , const std :: nothrow_t & ) throw ( ) ; 
void * operator new [ ] ( size_t ) throw ( std :: bad_alloc ) ; 
void * operator new [ ] ( size_t , const std :: nothrow_t & ) throw ( ) ; 
void operator delete [ ] ( void * ) throw ( ) ; 
void operator delete [ ] ( void * , const std :: nothrow_t & ) throw ( ) ; 

inline void * operator new [ ] ( size_t , void * __ptr ) throw ( ) { return __ptr ; } 
inline void * operator new ( size_t , void * __ptr ) throw ( ) { return __ptr ; } 
inline void operator delete ( void * , void * ) throw ( ) { } 
inline void operator delete [ ] ( void * , void * ) throw ( ) { } 
#63 "/opt/SUNWspro/SC5.0/include/CC/rw/iterator"
namespace std { 
#70
struct input_iterator_tag 
{ 
input_iterator_tag ( ) { ; } 
} ; 

struct output_iterator_tag 
{ 
output_iterator_tag ( ) { ; } 
} ; 

struct forward_iterator_tag : public input_iterator_tag 
{ 
forward_iterator_tag ( ) { ; } 
} ; 

struct bidirectional_iterator_tag : public forward_iterator_tag 
{ 
bidirectional_iterator_tag ( ) { ; } 
} ; 

struct random_access_iterator_tag : public bidirectional_iterator_tag 
{ 
random_access_iterator_tag ( ) { ; } 
} ; 
#106
template < class Category , class T , 
class Distance = ptrdiff_t , 
class Pointer = T * , 
class Reference = T & > 
struct iterator 
{ 
typedef T value_type ; 
typedef Distance difference_type ; 
typedef Pointer pointer ; 
typedef Reference reference ; 
typedef Category iterator_category ; 
} ; 
#169
template < class T > 
inline random_access_iterator_tag 
__iterator_category ( const T * ) 
{ 
return random_access_iterator_tag ( ) ; 
} 
#185
template < class Category , class T , class Distance , 
class Pointer , class Reference > 
inline Category 
__iterator_category ( const iterator < Category , T , Distance , Pointer , Reference > & ) 
{ 
typename iterator < Category , T , Distance , T * , T & > :: iterator_category tmp ; 
return tmp ; 
} 





template < class _TAG > 
inline bool __is_input_iterator ( _TAG ) 
{ return false ; } 

template < class _TAG > 
inline bool __is_bidirectional_iterator ( _TAG ) 
{ return false ; } 

template < class _TAG > 
inline bool __is_random_access_iterator ( _TAG ) 
{ return false ; } 

inline bool __is_input_iterator ( input_iterator_tag ) 
{ return true ; } 

inline bool __is_bidirectional_iterator ( bidirectional_iterator_tag ) 
{ return true ; } 

inline bool __is_bidirectional_iterator ( random_access_iterator_tag ) 
{ return true ; } 

inline bool __is_random_access_iterator ( random_access_iterator_tag ) 
{ return true ; } 




template < class Category , class T , class Distance , 
class Pointer , class Reference > 
inline T * __value_type ( const iterator < Category , T , Distance , Pointer , Reference > & ) 
{ 
return static_cast < T * > ( 0 ) ; 
} 
#239
template < class T > 
inline T * 
__value_type ( const T * ) 
{ 
return static_cast < T * > ( 0 ) ; 
} 




template < class Category , class T , class Distance , 
class Pointer , class Reference > 
inline Distance * 
__distance_type ( const iterator < Category , T , Distance , Pointer , Reference > & ) 
{ 
return static_cast < Distance * > ( 0 ) ; 
} 
#264
template < class T > 
inline ptrdiff_t * 
__distance_type ( const T * ) 
{ 
return static_cast < ptrdiff_t * > ( 0 ) ; 
} 





template < class InputIterator , class Distance > 
void __advance ( InputIterator & i , Distance n , input_iterator_tag ) ; 

template < class ForwardIterator , class Distance > 
void __advance ( ForwardIterator & i , Distance n , forward_iterator_tag ) ; 

template < class BidirectionalIterator , class Distance > 
void __advance ( BidirectionalIterator & i , Distance n , 
bidirectional_iterator_tag ) ; 

template < class InputIterator , class Distance > 
void __distance ( InputIterator first , InputIterator last , Distance & n , 
input_iterator_tag ) ; 

template < class ForwardIterator , class Distance > 
void __distance ( ForwardIterator first , ForwardIterator last , Distance & n , 
forward_iterator_tag ) ; 

template < class BidirectionalIterator , class Distance > 
void __distance ( BidirectionalIterator first , BidirectionalIterator last , 
Distance & n , bidirectional_iterator_tag ) ; 

template < class RandomAccessIterator , class Distance > 
inline void __distance ( RandomAccessIterator first , RandomAccessIterator last , 
Distance & n , random_access_iterator_tag ) 
{ 
n = last - first ; 
} 

template < class RandomAccessIterator , class Distance > 
inline void __advance ( RandomAccessIterator & i , Distance n , 
random_access_iterator_tag ) 
{ 
i += n ; 
} 





template < class ForwardIterator , class Distance > 
inline void distance ( ForwardIterator first , ForwardIterator last , Distance & n ) 
{ 

__distance ( first , last , n , __iterator_category ( first ) ) ; 



} 



template < class ForwardIterator , class Distance > 
inline void advance ( ForwardIterator & i , Distance n ) 
{ 

__advance ( i , n , __iterator_category ( i ) ) ; 



} 
#407
template < class Iterator , class Category , class T , 
class Reference = T & , 
class Pointer = T * , 
class Distance = ptrdiff_t > 
class reverse_iterator 
: public iterator < Category , T , Distance , Pointer , Reference > 

{ 
typedef reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > self ; 
public : 
typedef Distance difference_type ; 
typedef T value_type ; 
typedef Reference reference ; 
typedef Pointer pointer ; 
private : 
#429
friend inline bool operator == < > ( const self & x , const self & y ) ; 
friend inline bool operator < < > ( const self & x , const self & y ) ; 
friend inline difference_type operator - ( const self & x , const self & y ) ; 
friend inline self operator + ( difference_type n , const self & x ) ; 

protected : 

Iterator current ; 

public : 
typedef Iterator iterator_type ; 

reverse_iterator ( ) { } 
reverse_iterator ( Iterator x ) : current ( x ) { } 




Iterator base ( ) const { return current ; } 
reference operator * ( ) const 
{ Iterator tmp = current ; return * -- tmp ; } 

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


self & operator ++ ( ) { -- current ; return * this ; } 
self operator ++ ( int ) { self tmp = * this ; -- current ; return tmp ; } 
self & operator -- ( ) { ++ current ; return * this ; } 
self operator -- ( int ) { self tmp = * this ; ++ current ; return tmp ; } 

self operator + ( difference_type n ) const 
{ self tmp ( current - n ) ; return tmp ; } 
self & operator += ( difference_type n ) { current -= n ; return * this ; } 
self operator - ( difference_type n ) const { self tmp ( current + n ) ; return tmp ; } 
self & operator -= ( difference_type n ) { current += n ; return * this ; } 

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


template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator == ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return x . current == y . current ; 
} 

template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator < ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return y . current < x . current ; 
} 


template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator != ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return ! ( x == y ) ; 
} 

template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator > ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return y < x ; 
} 

template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator <= ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return ! ( y < x ) ; 
} 

template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator >= ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return ! ( x < y ) ; 
} 


template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline 



Distance 

operator - ( const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
const reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return y . current - x . current ; 
} 

template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > 




operator + ( Distance n , reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x ) 

{ 
return reverse_iterator < Iterator , Category , T , Reference , Pointer , Distance > ( x . current - n ) ; 
} 
#568
template < class Iterator , class Category , class T , 
class Reference = T & , 
class Pointer = T * , 
class Distance = ptrdiff_t > 
class __reverse_bi_iterator 
: public iterator < Category , T , Distance , Pointer , Reference > 

{ 
typedef __reverse_bi_iterator < Iterator , Category , T , Reference , Pointer , Distance > self ; 
typedef Distance difference_type ; 
typedef T value_type ; 
typedef Reference reference ; 
typedef Pointer pointer ; 

friend inline bool operator == ( const self & x , const self & y ) ; 

protected : 

Iterator current ; 

public : 
typedef Iterator iterator_type ; 

__reverse_bi_iterator ( ) { } 
__reverse_bi_iterator ( Iterator x ) : current ( x ) { } 




Iterator base ( ) const { return current ; } 
reference operator * ( ) const 
{ Iterator tmp = current ; return * -- tmp ; } 

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


self & operator ++ ( ) { -- current ; return * this ; } 
self operator ++ ( int ) { self tmp = * this ; -- current ; return tmp ; } 
self & operator -- ( ) { ++ current ; return * this ; } 
self operator -- ( int ) { self tmp = * this ; ++ current ; return tmp ; } 
} ; 


template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator == ( const __reverse_bi_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
#613

const __reverse_bi_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return x . current == y . current ; 
} 


template < class Iterator , class Category , class T , class Reference , class Pointer , class Distance > 
inline bool operator != ( const __reverse_bi_iterator < Iterator , Category , T , Reference , Pointer , Distance > & x , 
#621

const __reverse_bi_iterator < Iterator , Category , T , Reference , Pointer , Distance > & y ) 
{ 
return ! ( x == y ) ; 
} 
#634
template < class Container > 
class back_insert_iterator 
: public iterator < output_iterator_tag , void , void , void , void > 
{ 
protected : 

Container * container ; 

public : 
typedef Container container_type ; 

back_insert_iterator ( Container & x ) : container ( & x ) { } 
back_insert_iterator < Container > & 
operator = ( const typename Container :: const_reference value ) 
{ 
container -> push_back ( value ) ; return * this ; 
} 
back_insert_iterator < Container > & operator * ( ) { return * this ; } 
back_insert_iterator < Container > & operator ++ ( ) { return * this ; } 
back_insert_iterator < Container > operator ++ ( int ) { return * this ; } 
} ; 

template < class Container > 
inline back_insert_iterator < Container > back_inserter ( Container & x ) 
{ 
return back_insert_iterator < Container > ( x ) ; 
} 





template < class Container > 
class front_insert_iterator 
: public iterator < output_iterator_tag , 
typename Container :: value_type , 
typename Container :: difference_type , 
typename Container :: pointer , 
typename Container :: reference > 
{ 
protected : 

Container * container ; 

public : 
typedef Container container_type ; 
typedef typename Container :: value_type value_type ; 

front_insert_iterator ( Container & x ) : container ( & x ) { } 
front_insert_iterator < Container > & 
operator = ( const typename Container :: value_type & value ) 
{ 
container -> push_front ( value ) ; return * this ; 
} 
front_insert_iterator < Container > & operator * ( ) { return * this ; } 
front_insert_iterator < Container > & operator ++ ( ) { return * this ; } 
front_insert_iterator < Container > operator ++ ( int ) { return * this ; } 
} ; 

template < class Container > 
inline front_insert_iterator < Container > front_inserter ( Container & x ) 
{ 
return front_insert_iterator < Container > ( x ) ; 
} 





template < class Container > 
class insert_iterator 
: public iterator < output_iterator_tag , 
typename Container :: value_type , 
typename Container :: difference_type , 
typename Container :: pointer , 
typename Container :: reference > 
{ 
private : 
typename Container :: iterator iter ; 

protected : 
Container * container ; 

public : 
typedef Container container_type ; 
typedef typename Container :: value_type value_type ; 

insert_iterator ( Container & x , typename Container :: iterator i ) 
: container ( & x ) , iter ( i ) { } 
insert_iterator < Container > & 
operator = ( const typename Container :: value_type & value ) 
{ 
iter = container -> insert ( iter , value ) ; ++ iter ; return * this ; 
} 
insert_iterator < Container > & operator * ( ) { return * this ; } 
insert_iterator < Container > & operator ++ ( ) { return * this ; } 
insert_iterator < Container > & operator ++ ( int ) { return * this ; } 
} ; 

template < class Container , class Iterator > 
inline insert_iterator < Container > inserter ( Container & x , Iterator i ) 
{ 
typename Container :: iterator c ( i ) ; 
insert_iterator < Container > tmp ( x , c ) ; 
return tmp ; 
} 


template < class charT > struct char_traits ; 
template < > struct char_traits < char > ; 

template < > struct char_traits < wchar_t > ; 




} 
#760
namespace std { 
#881
} 
#50 "/opt/SUNWspro/SC5.0/include/CC/./utility"
namespace std { 



namespace rel_ops { 
#61
template < class T > 
inline bool operator != ( const T & x , const T & y ) 
{ 
return ! ( x == y ) ; 
} 

template < class T > 
inline bool operator > ( const T & x , const T & y ) 
{ 
return y < x ; 
} 

template < class T > 
inline bool operator <= ( const T & x , const T & y ) 
{ 
return ! ( y < x ) ; 
} 

template < class T > 
inline bool operator >= ( const T & x , const T & y ) 
{ 
return ! ( x < y ) ; 
} 


} 
#93
template < class T1 , class T2 > 
struct pair 
{ 
typedef T1 first_type ; 
typedef T2 second_type ; 

T1 first ; 
T2 second ; 
pair ( const T1 & a , const T2 & b ) : first ( a ) , second ( b ) { } 
pair ( ) 

: first ( T1 ( ) ) , second ( T2 ( ) ) 

{ ; } 

pair ( const pair & p ) 
: first ( p . first ) , second ( p . second ) 
{ ; } 
#117
} ; 

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 ! ( 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 pair < T1 , T2 > make_pair ( const T1 & x , const T2 & y ) 
{ 
return pair < T1 , T2 > ( x , y ) ; 
} 


} 
#9 "/usr/include/synch.h"
#pragma ident "@(#)synch.h	1.44	98/04/21 SMI" 
#9 "/usr/include/sys/machlock.h"
#pragma ident "@(#)machlock.h	1.19	98/04/14 SMI" 


extern "C" { 
#36
typedef lock_t disp_lock_t ; 
#55
extern int hres_lock ; 
extern int clock_res ; 
#77
} 
#9 "/usr/include/sys/synch.h"
#pragma ident "@(#)synch.h	1.35	98/06/05 SMI" 
#17
extern "C" { 
#25
typedef struct _lwp_mutex { 
struct _mutex_flags { 
uint16_t flag [ 2 ] ; 
union _mbcp_type_un { 
uint16_t bcptype ; 
struct _mtype_rcount { 
uint8_t count_type1 ; 
uint8_t count_type2 ; 
} mtype_rcount ; 
} mbcp_type_un ; 
uint16_t magic ; 
} flags ; 
union _mutex_lock_un { 
struct _mutex_lock { 
uint8_t pad [ 8 ] ; 
} lock64 ; 
upad64_t owner64 ; 
} lock ; 
upad64_t data ; 
} lwp_mutex_t ; 





typedef struct _lwp_cond { 
struct _lwp_cond_flags { 
uint8_t flag [ 4 ] ; 
uint16_t type ; 
uint16_t magic ; 
} flags ; 
upad64_t data ; 
} lwp_cond_t ; 
#64
typedef struct _lwp_sema { 
uint32_t count ; 
uint16_t type ; 
uint16_t magic ; 
uint8_t flags [ 8 ] ; 
upad64_t data ; 
} lwp_sema_t ; 
#95
} 
#23 "/usr/include/synch.h"
extern "C" { 
#31
typedef struct _sema { 

uint32_t count ; 
uint16_t type ; 
uint16_t magic ; 
upad64_t pad1 [ 3 ] ; 
upad64_t pad2 [ 2 ] ; 
} sema_t ; 
#51
typedef lwp_mutex_t mutex_t ; 
typedef lwp_cond_t cond_t ; 




typedef struct _rwlock { 
int32_t readers ; 
uint16_t type ; 
uint16_t magic ; 
uint16_t pad1 [ 4 ] ; 
upad64_t pad10 [ 2 ] ; 
uint16_t pad2 [ 4 ] ; 
upad64_t pad20 ; 
uint16_t pad3 [ 4 ] ; 
upad64_t pad30 ; 
} rwlock_t ; 


int _lwp_mutex_lock ( lwp_mutex_t * ) ; 
int _lwp_mutex_unlock ( lwp_mutex_t * ) ; 
int _lwp_mutex_trylock ( lwp_mutex_t * ) ; 
int _lwp_cond_wait ( lwp_cond_t * , lwp_mutex_t * ) ; 
int _lwp_cond_timedwait ( lwp_cond_t * , lwp_mutex_t * , timestruc_t * ) ; 
int _lwp_cond_signal ( lwp_cond_t * ) ; 
int _lwp_cond_broadcast ( lwp_cond_t * ) ; 
int _lwp_sema_init ( lwp_sema_t * , int ) ; 
int _lwp_sema_wait ( lwp_sema_t * ) ; 
int _lwp_sema_trywait ( lwp_sema_t * ) ; 
int _lwp_sema_post ( lwp_sema_t * ) ; 
int cond_init ( cond_t * , int , void * ) ; 
int cond_destroy ( cond_t * ) ; 
int cond_wait ( cond_t * , mutex_t * ) ; 
int cond_timedwait ( cond_t * , mutex_t * , timestruc_t * ) ; 
int cond_signal ( cond_t * ) ; 
int cond_broadcast ( cond_t * ) ; 
int mutex_init ( mutex_t * , int , void * ) ; 
int mutex_destroy ( mutex_t * ) ; 
int mutex_lock ( mutex_t * ) ; 
int mutex_trylock ( mutex_t * ) ; 
int mutex_unlock ( mutex_t * ) ; 
int rwlock_init ( rwlock_t * , int , void * ) ; 
int rwlock_destroy ( rwlock_t * ) ; 
int rw_rdlock ( rwlock_t * ) ; 
int rw_wrlock ( rwlock_t * ) ; 
int rw_unlock ( rwlock_t * ) ; 
int rw_tryrdlock ( rwlock_t * ) ; 
int rw_trywrlock ( rwlock_t * ) ; 
int sema_init ( sema_t * , unsigned int , int , void * ) ; 
int sema_destroy ( sema_t * ) ; 
int sema_wait ( sema_t * ) ; 
int sema_post ( sema_t * ) ; 
int sema_trywait ( sema_t * ) ; 
#201
int _sema_held ( sema_t * ) ; 
int _rw_read_held ( rwlock_t * ) ; 
int _rw_write_held ( rwlock_t * ) ; 
int _mutex_held ( mutex_t * ) ; 
#218
} 
#13 "/usr/include/thread.h"
#pragma ident "@(#)thread.h	1.45	98/09/02 SMI" 
#16 "/usr/include/sys/signal.h"
#pragma ident "@(#)signal.h	1.53	98/06/30 SMI" 
#25 "/usr/include/sys/unistd.h"
#pragma ident "@(#)unistd.h	1.36	98/07/16 SMI" 




extern "C" { 
#264
} 
#24 "/usr/include/sys/signal.h"
extern "C" { 
#71
extern long _sysconf ( int ) ; 





typedef void SIG_FUNC_TYP ( int ) ; 
typedef SIG_FUNC_TYP * SIG_TYP ; 
#16 "/usr/include/sys/siginfo.h"
#pragma ident "@(#)siginfo.h	1.54	98/03/27 SMI" 





extern "C" { 
#16 "/usr/include/sys/machsig.h"
#pragma ident "@(#)machsig.h	1.14	98/02/05 SMI" 





extern "C" { 
#110
} 
#221 "/usr/include/sys/siginfo.h"
typedef struct siginfo { 



int si_signo ; 
int si_code ; 
int si_errno ; 



union { 

int __pad [ ( ( 128 / sizeof ( int ) ) - 3 ) ] ; 

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


union sigval __value ; 



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

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

struct { 

int __fd ; 
long __band ; 
} __file ; 

struct { 
caddr_t __faddr ; 


timestruc_t __tstamp ; 



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

} __data ; 

} siginfo_t ; 
#354
typedef struct k_siginfo { 
int si_signo ; 
int si_code ; 
int si_errno ; 



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

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

struct { 

int __fd ; 
long __band ; 
} __file ; 

struct { 
caddr_t __faddr ; 



timestruc_t __tstamp ; 



short __syscall ; 
char __nsysarg ; 
char __fault ; 



} __prof ; 

} __data ; 

} k_siginfo_t ; 

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

} sigqueue_t ; 
#454
} 
#130 "/usr/include/sys/signal.h"
typedef struct { 
unsigned int __sigbits [ 4 ] ; 
} sigset_t ; 
#146
typedef struct { 
unsigned int __sigbits [ 2 ] ; 
} k_sigset_t ; 
#164
struct sigaction { 
int sa_flags ; 
union { 

void ( * _handler ) ( int ) ; 
#175
void ( * _sigaction ) ( int , siginfo_t * , void * ) ; 

} _funcptr ; 
sigset_t sa_mask ; 

int sa_resv [ 2 ] ; 

} ; 
#261
typedef struct sigaltstack { 



void * ss_sp ; 
size_t ss_size ; 
int ss_flags ; 
} stack_t ; 
#290
typedef struct signotify_id { 
pid_t sn_pid ; 
int sn_index ; 
int sn_pad ; 
} signotify_id_t ; 
#320
struct sigstack { 
void * ss_sp ; 
int ss_onstack ; 
} ; 
#400
} 
#28 "/usr/include/thread.h"
extern "C" { 



typedef unsigned int thread_t ; 
typedef unsigned int thread_key_t ; 





extern int thr_create ( void * , size_t , void * ( * ) ( void * ) , void * , long , 
thread_t * ) ; 
extern int thr_join ( thread_t , thread_t * , void * * ) ; 
extern int thr_setconcurrency ( int ) ; 
extern int thr_getconcurrency ( void ) ; 
extern void thr_exit ( void * ) ; 
extern thread_t thr_self ( void ) ; 
#53
extern int thr_sigsetmask ( int , const sigset_t * , sigset_t * ) ; 
#62
extern int thr_stksegment ( stack_t * ) ; 


extern int thr_main ( void ) ; 
extern int thr_kill ( thread_t , int ) ; 
extern int thr_suspend ( thread_t ) ; 
extern int thr_continue ( thread_t ) ; 
extern void thr_yield ( void ) ; 
extern int thr_setprio ( thread_t , int ) ; 
extern int thr_getprio ( thread_t , int * ) ; 
extern int thr_keycreate ( thread_key_t * , void ( * ) ( void * ) ) ; 
extern int thr_setspecific ( thread_key_t , void * ) ; 
extern int thr_getspecific ( thread_key_t , void * * ) ; 
extern size_t thr_min_stack ( void ) ; 
#127
} 
#51 "/opt/SUNWspro/SC5.0/include/CC/rw/stdmutex.h"
typedef mutex_t _RWSTDMutexType ; 
#94
class _RWSTDMutex 
{ 
private : 

_RWSTDMutexType mutex ; 




void init ( ) ; 



_RWSTDMutex & operator = ( const _RWSTDMutex & ) ; 

public : 

enum StaticCtor { staticCtor } ; 

_RWSTDMutex ( ) ; 
_RWSTDMutex ( const _RWSTDMutex & ) ; 
_RWSTDMutex ( StaticCtor ) ; 
~ _RWSTDMutex ( ) ; 

void acquire ( ) ; 
void release ( ) ; 
} ; 

class _RWSTDGuard 
{ 
private : 

_RWSTDMutex & rwmutex ; 

public : 

_RWSTDGuard ( _RWSTDMutex & m ) ; 
~ _RWSTDGuard ( ) ; 
} ; 
#141
inline _RWSTDMutex :: _RWSTDMutex ( _RWSTDMutex :: StaticCtor ) 
{ 



} 

inline _RWSTDMutex :: ~ _RWSTDMutex ( ) 
{ 
#157
mutex_destroy ( & mutex ) ; 
#167
} 


void inline _RWSTDMutex :: init ( ) 
{ 

mutex_init ( & mutex , 0 , 0 ) ; 
#188
} 

inline _RWSTDMutex :: _RWSTDMutex ( ) 
{ 
init ( ) ; 
} 

inline _RWSTDMutex :: _RWSTDMutex ( const _RWSTDMutex & ) 
{ 
init ( ) ; 
} 

inline void _RWSTDMutex :: acquire ( ) 
{ 





mutex_lock ( & mutex ) ; 
#217
} 

inline void _RWSTDMutex :: release ( ) 
{ 

mutex_unlock ( & mutex ) ; 
#232
} 

inline _RWSTDGuard :: _RWSTDGuard ( _RWSTDMutex & m ) : rwmutex ( m ) 
{ 
rwmutex . acquire ( ) ; 
} 

inline _RWSTDGuard :: ~ _RWSTDGuard ( ) { rwmutex . release ( ) ; } 
#88 "/opt/SUNWspro/SC5.0/include/CC/./memory"
namespace __rwstd { 





template < class T , class Base > 
class __rw_basis : public Base 
{ 
T __data_ ; 
public : 
__rw_basis ( const __rw_basis & b ) : __data_ ( b . __data_ ) { ; } 
__rw_basis ( const T & t , const Base & b ) : Base ( b ) , __data_ ( t ) { ; } 
__rw_basis ( int t , const Base & b ) : Base ( b ) , __data_ ( ( T ) t ) { ; } 
__rw_basis operator = ( const T & t ) { __data_ = t ; return * this ; } 
__rw_basis operator = ( int t ) { __data_ = ( T ) t ; return * this ; } 
__rw_basis operator = ( const __rw_basis & r ) 
{ __data_ = r . __data_ ; return * this ; } 
__rw_basis operator = ( const Base & b ) 
{ * this = __rw_basis < T , Base > ( __data_ , b ) ; return * this ; } 
operator T ( ) { return __data_ ; } 
T data ( ) const { return __data_ ; } 
} ; 
#127
template < class T , class size > 
inline size __rw_allocation_size ( T * , size cursize , size ) 
{ 
if ( cursize ) 
return cursize * 2 ; 
else 
return 1024 / sizeof ( T ) ; 
} 
#173
template < class T > 
inline void __destroy ( T * pointer ) 
{ 
#182
pointer -> ~ T ( ) ; 


} 


template < class T1 , class T2 > 
inline void __construct ( T1 * p , const T2 & value ) 
{ 
new ( p ) T1 ( value ) ; 
} 

template < class ForwardIterator > 
inline void __destroy ( ForwardIterator first , ForwardIterator last ) 
{ 
while ( first != last ) 
++ first ; 
} 
#257
extern const unsigned int rwse_OutOfRange ; 





} 

namespace std { 
#373
template < class T > 
class allocator 
{ 
public : 

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

allocator ( ) throw ( ) { ; } 
allocator ( const allocator < T > & ) throw ( ) 
{ ; } 
allocator < T > & operator = ( const allocator < T > & ) throw ( ) 
{ return * this ; } 

void * allocate ( size_type n , void * = 0 ) 
{ 
void * tmp = static_cast < void * > ( ( :: operator new ( static_cast < size_t > ( ( n ) ) ) ) ) ; 
if ( tmp == 0 ) throw bad_alloc ( ) ; 
return tmp ; 
} 

void deallocate ( void * p , size_type ) 
{ 
:: operator delete ( p ) ; 
} 
size_type max_size ( size_type size ) const 
{ 
return 1 > 4294967295U / size ? size_type ( 1 ) : size_type ( 4294967295U / size ) ; 
} 
} ; 

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 ; 

allocator ( ) throw ( ) { ; } 
allocator ( const allocator < void > & ) throw ( ) 
{ ; } 
allocator < void > & operator = ( const allocator < void > & ) throw ( ) 
{ return * this ; } 

void * allocate ( size_type n , void * = 0 ) 
{ 
void * tmp = static_cast < void * > ( ( :: operator new ( static_cast < size_t > ( ( n ) ) ) ) ) ; 
if ( tmp == 0 ) throw bad_alloc ( ) ; 
return tmp ; 
} 

void deallocate ( void * p , size_type ) 
{ 
:: operator delete ( p ) ; 
} 
size_type max_size ( size_type size ) const 
{ 
return 1 > 4294967295U / size ? size_type ( 1 ) : size_type ( 4294967295U / size ) ; 
} 
} ; 
#456
template < class Allocator , class T > 
class allocator_interface 
{ 
public : 
typedef Allocator allocator_type ; 
typedef T * pointer ; 
typedef const T * const_pointer ; 
typedef T & reference ; 
typedef const T & const_reference ; 
typedef T value_type ; 
typedef typename allocator_type :: size_type size_type ; 
typedef typename allocator_type :: difference_type difference_type ; 
typedef void * void_pointer ; 
typedef const void * const_void_pointer ; 



protected : 
allocator_type alloc_ ; 

public : 
allocator_interface ( ) throw ( ) { ; } 
allocator_interface ( const Allocator & a ) throw ( ) 
: alloc_ ( a ) { ; } 

pointer address ( T & x ) 
{ 
return static_cast < pointer > ( & x ) ; 
} 

size_type max_size ( ) const 
{ 
return alloc_ . max_size ( sizeof ( T ) ) ; 
} 

pointer allocate ( size_type n , pointer p = 0 ) 
{ 
return static_cast < pointer > ( alloc_ . allocate ( n * sizeof ( T ) , p ) ) ; 
} 

void deallocate ( pointer p , size_type n ) 
{ 
alloc_ . deallocate ( p , n ) ; 
} 

inline void construct ( pointer p , const T & val ) ; 

inline void destroy ( T * p ) ; 

} ; 


template < class Allocator , class T > 
inline void 
allocator_interface < Allocator , T > :: construct ( pointer p , const T & val ) 
{ 
__rwstd :: __construct ( p , val ) ; 
} 

template < class Allocator , class T > 
inline void allocator_interface < Allocator , T > :: destroy ( T * p ) 
{ 
__rwstd :: __destroy ( p ) ; 
} 

template < > 
class allocator_interface < allocator < void > , void > 
{ 
public : 
typedef allocator < void > allocator_type ; 
typedef void * pointer ; 
typedef const void * const_pointer ; 
typedef void value_type ; 
typedef allocator < void > :: size_type size_type ; 
typedef allocator < void > :: difference_type difference_type ; 

protected : 
allocator_type alloc_ ; 

public : 
allocator_interface ( ) throw ( ) { ; } 
allocator_interface ( const allocator < void > & a ) throw ( ) 
: alloc_ ( a ) { ; } 

size_type max_size ( ) const 
{ 
return alloc_ . max_size ( 1 ) ; 
} 

pointer allocate ( size_type n , pointer = 0 ) 
{ 
return static_cast < pointer > ( alloc_ . allocate ( n ) ) ; 
} 

void deallocate ( pointer p , size_type n ) 
{ 
alloc_ . deallocate ( p , n ) ; 
} 
} ; 
#561
template < class T , class U > 
inline bool operator == ( const allocator < T > & , const allocator < U > & ) throw ( ) 
{ 
return true ; 
} 


template < class T , class U > 
inline bool operator != ( const allocator < T > & , const allocator < U > & ) throw ( ) 
{ 
return false ; 
} 
#579
template < class OutputIterator , class T > 
class raw_storage_iterator 
: public iterator < output_iterator_tag , T , ptrdiff_t , T * , T & > 
{ 
protected : 
OutputIterator iter ; 

public : 
typedef OutputIterator iterator_type ; 
typedef T element_type ; 

raw_storage_iterator ( OutputIterator x ) : iter ( x ) { } 
raw_storage_iterator < OutputIterator , T > & operator * ( ) { return * this ; } 
raw_storage_iterator < OutputIterator , T > & operator = ( const T & element ) 
{ 
:: new ( & ( * iter ) ) T ( element ) ; 
return * this ; 
} 
raw_storage_iterator < OutputIterator , T > & operator ++ ( ) 
{ 
++ iter ; return * this ; 
} 
raw_storage_iterator < OutputIterator , T > operator ++ ( int ) 
{ 
raw_storage_iterator < OutputIterator , T > tmp = * this ; 
++ iter ; 
return tmp ; 
} 
} ; 
#709
template < class T > 



inline pair < T * , ptrdiff_t > get_temporary_buffer ( ptrdiff_t len , T * ) 

{ 
T * tmp = static_cast < T * > ( ( :: operator new ( len * sizeof ( T ) ) ) ) ; 
pair < T * , ptrdiff_t > result ( tmp , len ) ; 
return result ; 
} 

template < class T > 
inline void return_temporary_buffer ( T * p ) 
{ 
:: operator delete ( p ) ; 
} 
#734
template < class InputIterator , class ForwardIterator > 
inline ForwardIterator uninitialized_copy ( InputIterator first , InputIterator last , 
ForwardIterator result ) 
{ 
ForwardIterator start = result ; 

try { 
while ( first != last ) 
__rwstd :: __construct ( result ++ , * first ++ ) ; 
} catch ( ... ) { 
__rwstd :: __destroy ( start , result ) ; 
throw ; 
} 





return result ; 
} 

template < class ForwardIterator , class T > 
inline void uninitialized_fill ( ForwardIterator first , ForwardIterator last , 
const T & x ) 
{ 
ForwardIterator start = first ; 

try { 
while ( first != last ) 
__rwstd :: __construct ( first ++ , x ) ; 
} catch ( ... ) { 
__rwstd :: __destroy ( start , first ) ; 
throw ; 
} 




} 

template < class ForwardIterator , class Size , class T > 
inline void uninitialized_fill_n ( ForwardIterator first , Size n , const T & x ) 
{ 
ForwardIterator start = first ; 

try { 
while ( n -- ) 
__rwstd :: __construct ( first ++ , x ) ; 
} catch ( ... ) { 
__rwstd :: __destroy ( start , first ) ; 
throw ; 
} 




} 
#800
template < class X > class auto_ptr 
{ 
#811
public : 
typedef X element_type ; 




auto_ptr ( X * p = 0 ) throw ( ) 
: the_p ( p ) 
{ ; } 

auto_ptr ( auto_ptr < X > & a ) throw ( ) 
: the_p ( ( const_cast < auto_ptr < X > & > ( a ) ) . release ( ) ) 
{ ; } 

auto_ptr < X > & operator = ( auto_ptr < X > & rhs ) throw ( ) 
{ 
reset ( rhs . release ( ) ) ; 
return * this ; 
} 
#844
~ auto_ptr ( ) throw ( ) { delete the_p ; } 



X & operator * ( ) const throw ( ) { return * the_p ; } 
X * operator -> ( ) const throw ( ) { return the_p ; } 
X * get ( ) const throw ( ) { return the_p ; } 

X * release ( ) throw ( ) 
{ 
X * tmp = the_p ; 
the_p = 0 ; 
return tmp ; 
} 

void reset ( X * p = 0 ) throw ( ) 
{ 
if ( the_p != p ) 
{ 
delete the_p ; 
the_p = p ; 
} 
} 
#887
private : 
X * the_p ; 
} ; 



} 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/stdio.h"
#pragma ident "@(#)stdio.h	1.9  02/24/99 C++5.0" 
#9 "/usr/include/stdio_impl.h"
#pragma ident "@(#)stdio_impl.h	1.7	98/04/17 SMI" 




extern "C" { 
#38
struct __FILE 
{ 




ssize_t _cnt ; 
unsigned char * _ptr ; 

unsigned char * _base ; 
unsigned char _flag ; 
unsigned char _file ; 
unsigned __orientation : 2 ; 
unsigned __filler : 6 ; 
} ; 




} 
#28 "/opt/SUNWspro/SC5.0/include/CC/std/stdio.h"
extern "C" { 
#41
typedef long long __longlong_t ; 
#117
namespace std { 
#136
typedef __FILE FILE ; 



extern "C" FILE __iob [ 20 ] ; 




} 

using std :: __iob ; 


extern unsigned char _sibuf [ ] , _sobuf [ ] ; 
#181
namespace std { 




typedef __FILE FILE ; 
#203
typedef long off_t ; 
#211
typedef __longlong_t off64_t ; 
#218
typedef long fpos_t ; 
#226
typedef __longlong_t fpos64_t ; 



extern int remove ( const char * ) ; 
extern int rename ( const char * , const char * ) ; 
extern FILE * tmpfile ( void ) ; 
extern char * tmpnam ( char * ) ; 
extern int fclose ( FILE * ) ; 
extern int fflush ( FILE * ) ; 
extern FILE * fopen ( const char * , const char * ) ; 
extern FILE * freopen ( const char * , const char * , FILE * ) ; 
extern void setbuf ( FILE * , char * ) ; 
extern int setvbuf ( FILE * , char * , int , size_t ) ; 
extern int fprintf ( FILE * , const char * , ... ) ; 
extern int fscanf ( FILE * , const char * , ... ) ; 
extern int printf ( const char * , ... ) ; 
extern int scanf ( const char * , ... ) ; 
extern int sprintf ( char * , const char * , ... ) ; 
extern int sscanf ( const char * , const char * , ... ) ; 
extern int vfprintf ( FILE * , const char * , __va_list ) ; 
extern int vprintf ( const char * , __va_list ) ; 
extern int vsprintf ( char * , const char * , __va_list ) ; 
extern int fgetc ( FILE * ) ; 
extern char * fgets ( char * , int , FILE * ) ; 
extern int fputc ( int , FILE * ) ; 
extern int fputs ( const char * , FILE * ) ; 
extern int getc ( FILE * ) ; 
extern int getchar ( void ) ; 
extern char * gets ( char * ) ; 
extern int putc ( int , FILE * ) ; 
extern int putchar ( int ) ; 
extern int puts ( const char * ) ; 
extern int ungetc ( int , FILE * ) ; 
extern size_t fread ( void * , size_t , size_t , FILE * ) ; 
extern size_t fwrite ( const void * , size_t , size_t , FILE * ) ; 
extern int fgetpos ( FILE * , fpos_t * ) ; 
extern int fseek ( FILE * , long , int ) ; 
extern int fsetpos ( FILE * , const fpos_t * ) ; 
extern long ftell ( FILE * ) ; 
extern void rewind ( FILE * ) ; 
extern void clearerr ( FILE * ) ; 
extern int feof ( FILE * ) ; 
extern int ferror ( FILE * ) ; 
extern void perror ( const char * ) ; 

} 

} 
#284
using std :: FILE ; 
using std :: fpos_t ; 
using std :: size_t ; 
using std :: clearerr ; 
using std :: fclose ; 
using std :: feof ; 
using std :: ferror ; 
using std :: fflush ; 
using std :: fgetc ; 
using std :: fgetpos ; 
using std :: fgets ; 
using std :: fopen ; 
using std :: fprintf ; 
using std :: fputc ; 
using std :: fputs ; 
using std :: fread ; 
using std :: freopen ; 
using std :: fscanf ; 
using std :: fseek ; 
using std :: fsetpos ; 
using std :: ftell ; 
using std :: fwrite ; 
using std :: getc ; 
using std :: getchar ; 
using std :: gets ; 
using std :: perror ; 
using std :: printf ; 
using std :: putc ; 
using std :: putchar ; 
using std :: puts ; 
using std :: remove ; 
using std :: rename ; 
using std :: rewind ; 
using std :: scanf ; 
using std :: setbuf ; 
using std :: setvbuf ; 
using std :: sprintf ; 
using std :: sscanf ; 
using std :: tmpfile ; 
using std :: tmpnam ; 
using std :: ungetc ; 
using std :: vfprintf ; 
using std :: vprintf ; 
using std :: vsprintf ; 

#pragma override_linkname 
typedef FILE __FILE ; 
#pragma no_override_linkname 
#341
extern "C" { 
#372
extern void setbuffer ( FILE * , char * , size_t ) ; 
extern int setlinebuf ( FILE * ) ; 
#380
extern int snprintf ( char * , size_t , const char * , ... ) ; 
extern int vsnprintf ( char * , size_t , const char * , __va_list ) ; 
#390
extern FILE * fdopen ( int , const char * ) ; 
extern char * ctermid ( char * ) ; 
extern int fileno ( FILE * ) ; 
#416
extern FILE * popen ( const char * , const char * ) ; 
extern char * cuserid ( char * ) ; 
extern char * tempnam ( const char * , const char * ) ; 
extern int getopt ( int , char * const * , const char * ) ; 

extern int getsubopt ( char * * , char * const * , char * * ) ; 

extern char * optarg ; 
extern int optind , opterr , optopt ; 
extern int getw ( FILE * ) ; 
extern int putw ( int , FILE * ) ; 
extern int pclose ( FILE * ) ; 
#435
extern int fseeko ( FILE * , std :: off_t , int ) ; 
extern std :: off_t ftello ( FILE * ) ; 
#445
extern FILE * fopen64 ( const char * , const char * ) ; 
extern FILE * freopen64 ( const char * , const char * , FILE * ) ; 
extern FILE * tmpfile64 ( void ) ; 
extern int fgetpos64 ( FILE * , std :: fpos64_t * ) ; 
extern int fsetpos64 ( FILE * , const std :: fpos64_t * ) ; 
extern int fseeko64 ( FILE * , std :: off64_t , int ) ; 
extern std :: off64_t ftello64 ( FILE * ) ; 
#500
} 


extern "C" unsigned char * _bufendtab [ ] ; 
extern "C" std :: FILE * _lastbuf ; 
extern "C" int __filbuf ( std :: FILE * ) ; 
extern "C" int __flsbuf ( int , std :: FILE * ) ; 
#37 "/opt/SUNWspro/SC5.0/include/CC/./iosfwd"
namespace std { 


class mbstate_t ; 


} 




using std :: mbstate_t ; 
#57
namespace std { 


template < class charT > struct char_traits ; 

template < class T > class allocator ; 

template < class stateT > class fpos ; 


class mbstate_t ; 


typedef fpos < mbstate_t > streampos ; 
typedef fpos < mbstate_t > wstreampos ; 

typedef long streamoff ; 
typedef long wstreamoff ; 


} 





namespace std { 



template < class charT , class traits = char_traits < charT > > class basic_ios ; 
template < class charT , class traits = char_traits < charT > > class basic_streambuf ; 
template < class charT , class traits = char_traits < charT > > class basic_istream ; 
template < class charT , class traits = char_traits < charT > > class basic_ostream ; 
template < class charT , class traits = char_traits < charT > , class Allocator = allocator < charT > > 
class basic_stringbuf ; 
template < class charT , class traits = char_traits < charT > , class Allocator = allocator < charT > > 
class basic_istringstream ; 
template < class charT , class traits = char_traits < charT > , class Allocator = allocator < charT > > 
class basic_ostringstream ; 
template < class charT , class traits = char_traits < charT > > class basic_filebuf ; 
template < class charT , class traits = char_traits < charT > > class basic_ifstream ; 
template < class charT , class traits = char_traits < charT > > class basic_ofstream ; 
template < class T , class charT = char , class traits = char_traits < charT > > 
class ostream_iterator ; 
template < class T , class charT = char , class traits = char_traits < charT > , 
class Distance = ptrdiff_t > 
class istream_iterator ; 
template < class charT , class traits = char_traits < charT > > 
class ostreambuf_iterator ; 
template < class charT , class traits = char_traits < charT > > 
class istreambuf_iterator ; 
template < class charT , class traits = char_traits < charT > > class 
basic_iostream ; 
template < class charT , class traits = char_traits < charT > > class 
basic_fstream ; 
template < class charT , class traits = char_traits < charT > , class Allocator = allocator < charT > > 
class basic_stringstream ; 
#136
typedef basic_ios < char > ios ; 
typedef basic_streambuf < char > streambuf ; 
typedef basic_istream < char > istream ; 
typedef basic_ostream < char > ostream ; 
typedef basic_stringbuf < char > stringbuf ; 
typedef basic_istringstream < char > istringstream ; 
typedef basic_ostringstream < char > ostringstream ; 
typedef basic_filebuf < char > filebuf ; 
typedef basic_ifstream < char > ifstream ; 
typedef basic_ofstream < char > ofstream ; 
typedef basic_fstream < char > fstream ; 
typedef basic_iostream < char > iostream ; 
typedef basic_stringstream < char > stringstream ; 

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_stringbuf < wchar_t > wstringbuf ; 
typedef basic_istringstream < wchar_t > wistringstream ; 
typedef basic_ostringstream < wchar_t > wostringstream ; 
typedef basic_filebuf < wchar_t > wfilebuf ; 
typedef basic_ifstream < wchar_t > wifstream ; 
typedef basic_ofstream < wchar_t > wofstream ; 
typedef basic_fstream < wchar_t > wfstream ; 
typedef basic_iostream < wchar_t > wiostream ; 
typedef basic_stringstream < wchar_t > wstringstream ; 
#196
} 
#36 "/opt/SUNWspro/SC5.0/include/CC/rw/iotraits"
namespace std { 
#44
struct mbstate_t 
{ 
mbstate_t ( long state = 0 ) 
: __mbstate ( state ) { ; } 

mbstate_t ( const mbstate_t & state ) 
: __mbstate ( state . __mbstate ) { ; } 

mbstate_t & operator = ( const mbstate_t & state ) 
{ 
if ( & state != this ) 
__mbstate = state . __mbstate ; 
return * this ; 
} 

mbstate_t & operator = ( const long state ) 
{ 
__mbstate = state ; 
return * this ; 
} 

bool operator == ( const mbstate_t & state ) const 
{ 
return ( __mbstate == state . __mbstate ) ; 
} 

bool operator != ( const mbstate_t & state ) const 
{ 
return ( ! ( __mbstate == state . __mbstate ) ) ; 
} 

long __mbstate ; 
} ; 
#89
template < class stateT > 
class fpos 
{ 
public : 



typedef stateT state_type ; 

inline fpos ( long off = 0 ) ; 


inline fpos ( state_type ) ; 

inline operator long ( ) const ; 

inline fpos ( const fpos < stateT > & ) ; 
inline fpos < stateT > & operator = ( const fpos < stateT > & ) ; 

inline state_type state ( ) const ; 
inline state_type state ( state_type ) ; 

inline fpos < stateT > & operator += ( const fpos < stateT > & off ) ; 
inline fpos < stateT > operator + ( const fpos < stateT > & off ) const ; 

inline fpos < stateT > & operator -= ( const fpos < stateT > & off ) ; 
inline fpos < stateT > operator - ( const fpos < stateT > & off ) const ; 

inline fpos < stateT > & operator += ( int off ) ; 
inline fpos < stateT > operator + ( int off ) const ; 

inline fpos < stateT > & operator -= ( int off ) ; 
inline fpos < stateT > operator - ( int off ) const ; 

inline fpos < stateT > & operator += ( long off ) ; 
inline fpos < stateT > operator + ( long off ) const ; 

inline fpos < stateT > & operator -= ( long off ) ; 
inline fpos < stateT > operator - ( long off ) const ; 

inline bool operator == ( const fpos < stateT > & rhs ) const ; 
inline bool operator != ( const fpos < stateT > & rhs ) const ; 

inline bool operator < ( const fpos < stateT > & rhs ) const ; 
inline bool operator > ( const fpos < stateT > & rhs ) const ; 

inline bool operator <= ( const fpos < stateT > & rhs ) const ; 
inline bool operator >= ( const fpos < stateT > & rhs ) const ; 

inline bool operator == ( const int & rhs ) const ; 
inline bool operator != ( const int & rhs ) const ; 

inline bool operator < ( const int & rhs ) const ; 
inline bool operator > ( const int & rhs ) const ; 

inline bool operator <= ( const int & rhs ) const ; 
inline bool operator >= ( const int & rhs ) const ; 

inline bool operator == ( const long & rhs ) const ; 
inline bool operator != ( const long & rhs ) const ; 

inline bool operator < ( const long & rhs ) const ; 
inline bool operator > ( const long & rhs ) const ; 

inline bool operator <= ( const long & rhs ) const ; 
inline bool operator >= ( const long & rhs ) const ; 

private : 

long __pos ; 
state_type __state ; 
bool __status ; 
} ; 
#172
template < class stateT > 
inline 
fpos < stateT > :: fpos ( long off ) 
: __pos ( off ) 
, __state ( stateT ( ) ) 
, __status ( true ) 
{ 
if ( off == - 1 ) __status = false ; 
} 
#187
template < class stateT > 
inline 
fpos < stateT > :: fpos ( stateT state ) 
: __pos ( 0 ) 
, __state ( state ) 
, __status ( true ) 
{ ; } 
#200
template < class stateT > 
inline 
fpos < stateT > :: fpos ( const fpos < stateT > & str_pos ) 
{ 
__pos = str_pos . __pos ; 
__state = str_pos . __state ; 
__status = str_pos . __status ; 
} 





template < class stateT > 
inline typename fpos < stateT > :: state_type 
fpos < stateT > :: state ( state_type state ) 
{ 
state_type var = __state ; 
__state = state ; 
return var ; 
} 





template < class stateT > 
inline fpos < stateT > :: operator long ( ) const 
{ 
return ( long ) __pos ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator = ( const fpos < stateT > & str_pos ) 
{ 
if ( & str_pos != this ) 
{ 
__pos = str_pos . __pos ; 
__state = str_pos . __state ; 
__status = str_pos . __status ; 
} 
return * this ; 
} 





template < class stateT > 
inline typename fpos < stateT > :: state_type 
fpos < stateT > :: state ( ) const 
{ 
return __state ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator += ( const fpos < stateT > & off ) 
{ 
__pos += off . __pos ; 
return * this ; 
} 





template < class stateT > 
inline fpos < stateT > 
fpos < stateT > :: operator + ( const fpos < stateT > & off ) const 
{ 
fpos < stateT > temp ( * this ) ; 
temp . __pos += off . __pos ; 
return temp ; 
} 





template < class stateT > 
inline fpos < stateT > 
fpos < stateT > :: operator - ( const fpos < stateT > & off ) const 
{ 
fpos < stateT > temp ( * this ) ; 
temp . __pos -= off . __pos ; 
return temp ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator -= ( const fpos < stateT > & off ) 
{ 
__pos -= off . __pos ; 
return * this ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator += ( int off ) 
{ 
__pos += off ; 
return * this ; 
} 





template < class stateT > 
inline fpos < stateT > 
fpos < stateT > :: operator + ( int off ) const 
{ 
fpos < stateT > temp ( * this ) ; 
temp . __pos += off ; 
return temp ; 
} 





template < class stateT > 
inline fpos < stateT > 
fpos < stateT > :: operator - ( int off ) const 
{ 
fpos < stateT > temp ( * this ) ; 
temp . __pos -= off ; 
return temp ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator -= ( int off ) 
{ 
__pos -= off ; 
return * this ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator -= ( long off ) 
{ 
__pos -= off ; 
return * this ; 
} 





template < class stateT > 
inline fpos < stateT > 
fpos < stateT > :: operator - ( long off ) const 
{ 
fpos < stateT > temp ( * this ) ; 
temp . __pos -= off ; 
return temp ; 
} 





template < class stateT > 
inline fpos < stateT > & 
fpos < stateT > :: operator += ( long off ) 
{ 
__pos += off ; 
return * this ; 
} 





template < class stateT > 
inline fpos < stateT > 
fpos < stateT > :: operator + ( long off ) const 
{ 
fpos < stateT > temp ( * this ) ; 
temp . __pos += off ; 
return temp ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator == ( const fpos < stateT > & pos ) const 
{ 
if ( ! ( __status || pos . __status ) ) return true ; 
return ( ( __pos == pos . __pos ) 



&& ( __status == pos . __status ) ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator != ( const fpos < stateT > & pos ) const 
{ 
return ! ( * this == pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator < ( const fpos < stateT > & pos ) const 
{ 
return ( __pos < pos . __pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator > ( const fpos < stateT > & pos ) const 
{ 
return ( __pos > pos . __pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator <= ( const fpos < stateT > & pos ) const 
{ 
return ( __pos <= pos . __pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator >= ( const fpos < stateT > & pos ) const 
{ 
return ( __pos >= pos . __pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator == ( const int & pos ) const 
{ 
return ( __pos == pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator != ( const int & pos ) const 
{ 
return ! ( * this == pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator < ( const int & pos ) const 
{ 
return ( __pos < pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator > ( const int & pos ) const 
{ 
return ( __pos > pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator <= ( const int & pos ) const 
{ 
return ( __pos <= pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator >= ( const int & pos ) const 
{ 
return ( __pos >= pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator == ( const long & pos ) const 
{ 
return ( __pos == pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator != ( const long & pos ) const 
{ 
return ! ( * this == pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator < ( const long & pos ) const 
{ 
return ( __pos < pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator > ( const long & pos ) const 
{ 
return ( __pos > pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator <= ( const long & pos ) const 
{ 
return ( __pos >= pos ) ; 
} 





template < class stateT > 
inline bool 
fpos < stateT > :: operator >= ( const long & pos ) const 
{ 
return ( __pos <= pos ) ; 
} 


} 
#57 "/opt/SUNWspro/SC5.0/include/CC/rw/traits"
namespace std { 
#64
template < class charT > 
struct char_traits 
{ 
typedef charT char_type ; 
typedef long int_type ; 


typedef wstreamoff off_type ; 
typedef mbstate_t state_type ; 
typedef fpos < state_type > pos_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 ) 
{ 
size_t i = 0 ; 

while ( i < n ) 
{ 
if ( ! eq ( s1 [ i ] , s2 [ i ] ) ) 
{ 
if ( lt ( s1 [ i ] , s2 [ i ] ) ) 
return - 1 ; 
else 
return 1 ; 
} 
i ++ ; 
} 
return 0 ; 
} 

static size_t length ( const char_type * s ) 
{ 
size_t l = 0 ; 
while ( ! eq ( * s ++ , char_type ( 0 ) ) ) ++ l ; 
return l ; 
} 

static const char_type * 
find ( const char_type * s , size_t n , const char_type & a ) 
{ 
while ( n -- > 0 && * s != a ) 
++ s ; 
return * s == a ? s : 0 ; 
} 

static char_type * move ( char_type * s1 , const char_type * s2 , size_t n ) 
{ 
char_type * s = s1 ; 
if ( s1 < s2 ) 
copy ( s1 , s2 , n ) ; 
else if ( s1 > s2 ) 
{ 
s1 += n ; 
s2 += n ; 
for ( size_t i = 0 ; i < n ; ++ i ) 
assign ( * -- s1 , * -- s2 ) ; 
} 
return s1 ; 
} 

static char_type * copy ( char_type * dst , const char_type * src , size_t n ) 
{ 
memcpy ( ( char * ) dst , ( char * ) src , n * sizeof ( char_type ) ) ; 
return dst ; 
} 

static char_type * assign ( char_type * s , size_t n , char_type a ) 
{ 
char_type * tmp = s ; 
while ( n -- > 0 ) 
* tmp ++ = a ; 
return s ; 
} 

static int_type not_eof ( const int_type & c ) 
{ 
if ( c == ( - 1 ) ) 
return 0 ; 
else 
return c ; 
} 

static char_type to_char_type ( const int_type & c ) 
{ return c ; } 
static int_type to_int_type ( const char_type & c ) 
{ return c ; } 

static bool eq_int_type ( const int_type & c1 , const int_type & c2 ) 
{ return ( c1 == c2 ) ; } 


static state_type get_state ( pos_type pos ) 
{ return pos . state ( ) ; } 


static int_type eof ( ) 
{ return ( - 1 ) ; } 


} ; 
#181
template < > 
struct char_traits < char > 
{ 

typedef char char_type ; 
typedef int int_type ; 


typedef streamoff off_type ; 
typedef streampos 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 memcmp ( s1 , s2 , n ) ; } 

static const char_type * find ( const char_type * s , 
size_t n , const char_type & a ) 
{ return ( char_type * ) memchr ( s , a , n ) ; } 

static size_t length ( const char_type * s ) 
{ return strlen ( s ) ; } 

static char_type * move ( char_type * s1 , const char_type * s2 , size_t n ) 
{ 

memmove ( s1 , s2 , n ) ; 
#229
return s1 ; 
} 

static char_type * copy ( char_type * dst , const char_type * src , size_t n ) 
{ 
memcpy ( dst , src , n ) ; 
return dst ; 
} 

static char_type * assign ( char_type * s , size_t n , char_type a ) 
{ 
memset ( s , a , n ) ; 
return s ; 
} 

static int_type not_eof ( const int_type & c ) 
{ 
if ( c == ( - 1 ) ) 
return 0 ; 
else 
return c ; 
} 

static char_type to_char_type ( const int_type & c ) 
{ return ( char ) c ; } 
static int_type to_int_type ( const char_type & c ) 
{ return ( unsigned char ) c ; } 

static bool eq_int_type ( const int_type & c1 , const int_type & c2 ) 
{ return ( c1 == c2 ) ; } 


static state_type get_state ( pos_type pos ) 
{ return pos . state ( ) ; } 


static int_type eof ( ) 
{ return ( - 1 ) ; } 


} ; 
#281
template < > 
struct char_traits < wchar_t > 
{ 
typedef wchar_t char_type ; 


typedef wint_t int_type ; 
#297
typedef wstreamoff 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 ) 
{ 



size_t i = 0 ; 

while ( i < n ) 
{ 
if ( ! eq ( s1 [ i ] , s2 [ i ] ) ) 
{ 
if ( lt ( s1 [ i ] , s2 [ i ] ) ) 
return - 1 ; 
else 
return 1 ; 
} 
i ++ ; 
} 
return 0 ; 

} 


static size_t length ( const char_type * s ) 
{ 



size_t l = 0 ; 
while ( ! eq ( * s ++ , char_type ( 0 ) ) ) ++ l ; 
return l ; 

} 

static const char_type * find ( const char_type * s , size_t n , 
const char_type & a ) 
{ 



while ( n -- > 0 && * s != a ) 
++ s ; 
return * s == a ? s : 0 ; 

} 

static char_type * move ( char_type * s1 , const char_type * s2 , size_t n ) 
{ 

memmove ( s1 , s2 , n * sizeof ( char_type ) ) ; 
#372
return s1 ; 
} 

static char_type * copy ( char_type * dst , const char_type * src , size_t n ) 
{ 
memcpy ( ( char * ) dst , ( char * ) src , n * sizeof ( char_type ) ) ; 
return dst ; 
} 

static char_type * assign ( char_type * s , size_t n , char_type a ) 
{ 



char_type * tmp = s ; 
while ( n -- > 0 ) 
* tmp ++ = a ; 

return s ; 
} 

static int_type not_eof ( const int_type & c ) 
{ 
if ( c == ( ( wint_t ) ( - 1 ) ) ) 
return 0 ; 
else 
return c ; 
} 

static char_type to_char_type ( const int_type & c ) 
{ return c ; } 
static int_type to_int_type ( const char_type & c ) 
{ return c ; } 

static bool eq_int_type ( const int_type & c1 , const int_type & c2 ) 
{ return ( c1 == c2 ) ; } 


static state_type get_state ( pos_type pos ) 
{ return pos . state ( ) ; } 


static int_type eof ( ) 
{ return ( ( wint_t ) ( - 1 ) ) ; } 
} ; 





} namespace __rwstd { 
#429
template < class charT , class traits > 
struct rw_traits 
{ 
static const charT * find ( const charT * s , const charT * v ) 
{ 
size_t slen = traits :: length ( s ) ; 
size_t vlen = traits :: length ( v ) ; 
for ( size_t xpos = 0 ; ( xpos + vlen ) <= slen ; xpos ++ ) 
{ 
bool found = true ; 
for ( size_t i = 0 ; i < vlen ; i ++ ) 
{ 
if ( ! traits :: eq ( s [ xpos + i ] , v [ i ] ) ) 
{ 
found = false ; 
break ; 
} 
} 
if ( found ) 
return & s [ xpos ] ; 
} 
return 0 ; 
} 

static const charT * rfind ( const charT * s , charT v , size_t pos ) 
{ 
const charT * p = s + pos ; 
while ( p >= s ) 
{ 
if ( traits :: eq ( * p , v ) ) 
return p ; 
p -- ; 
} 
return 0 ; 
} 

static size_t find_first_of ( const charT * s , const charT * v ) 
{ 
const charT * p = s ; 
for ( ; * p ; p ++ ) 
{ 
for ( const charT * q = v ; * q ; q ++ ) 
if ( traits :: eq ( * p , * q ) ) 
return p - s ; 
} 
return p - s ; 
} 

static size_t find_first_not_of ( const charT * s , const charT * v ) 
{ 
const charT * p = s ; 
for ( ; * p ; p ++ ) 
{ 
for ( const charT * q = v ; * q ; q ++ ) 
if ( ! traits :: eq ( * p , * q ) ) 
return p - s ; 
} 
return p - s ; 
} 
} ; 

template < > 
struct rw_traits < char , std :: char_traits < char > > 
{ 
static const char * find ( const char * s , const char * v ) 



{ return strstr ( s , v ) ; } 

static const char * rfind ( const char * s , char v , size_t pos ) 
{ 
const char * p = s + pos ; 
while ( p >= s ) 
{ 
if ( std :: char_traits < char > :: eq ( * p , v ) ) 
return p ; 
p -- ; 
} 
return 0 ; 
} 
static size_t find_first_of ( const char * s , const char * v ) 



{ return strcspn ( s , v ) ; } 

static size_t find_first_not_of ( const char * s , const char * v ) 



{ return strspn ( s , v ) ; } 

} ; 
#567
} 
#39 "/opt/SUNWspro/SC5.0/include/CC/rw/string_ref"
namespace std { 





template < class charT , class traits = char_traits < charT > , 
class Allocator = allocator < charT > > 
class basic_string ; 


} namespace __rwstd { 
#65
template < class Allocator > 
class __string_noref_rep 
{ 
public : 
__string_noref_rep ( long refs = 0 ) 
: __refs_ ( ( bool ) refs ) , __capacity_ ( 0 ) , __nchars_ ( 0 ) { ; } 
__string_noref_rep ( const __string_noref_rep & r ) 
: __refs_ ( ( bool ) r . __refs_ ) , __capacity_ ( 0 ) , __nchars_ ( 0 ) { ; } 

typedef Allocator allocator_type ; 
typedef typename allocator_type :: size_type size_type ; 

protected : 

bool __refs_ ; 
size_type __capacity_ ; 
size_type __nchars_ ; 
} ; 

template < class charT , class traits , class Allocator > 
class __string_noref 
: public __string_noref_rep < Allocator > 
{ 
public : 
typedef __string_noref_rep < Allocator > __string_ref_rep_type ; 
typedef typename __string_noref_rep < Allocator > :: size_type size_type ; 

__string_noref ( long = 0 ) 
{ ; } 

private : 
long __references ( ) const 
{ 
return ( long ) __string_noref_rep < Allocator > :: __refs_ ; 
} 
void __setRefCount ( long r ) 
{ ; } 
void __addReference ( ) 
{ ; } 
long __removeReference ( ) 
{ 
return ( long ) __string_noref_rep < Allocator > :: __refs_ ; 
} 
size_type length ( ) const 
{ 
return __string_noref_rep < Allocator > :: __nchars_ ; 
} 
size_type __getCapac ( ) const 
{ 
return __string_noref_rep < Allocator > :: __capacity_ ; 
} 
charT * data ( ) const 
{ 
return ( charT * ) ( this + 1 ) ; 
} 
charT & operator [ ] ( size_type i ) 
{ 
return ( reinterpret_cast < charT * > ( ( this + 1 ) ) ) [ i ] ; 
} 
const charT & operator [ ] ( size_type i ) const 
{ 
return ( ( charT * ) ( this + 1 ) ) [ i ] ; 
} 

friend class std :: basic_string < charT , traits , Allocator > ; 



} ; 
#148
template < class Allocator > 
class __string_ref_rep 
{ 
public : 




__string_ref_rep ( ) 
: __refs_ ( 0 ) , __capacity_ ( 0 ) , __nchars_ ( 0 ) { ; } 
__string_ref_rep ( long x ) 
: __refs_ ( x ) , __capacity_ ( 0 ) , __nchars_ ( 0 ) { ; } 
__string_ref_rep ( const __string_ref_rep & r ) 
: __refs_ ( r . __refs_ ) , __capacity_ ( 0 ) , __nchars_ ( 0 ) { ; } 

typedef Allocator allocator_type ; 
typedef typename allocator_type :: size_type size_type ; 

protected : 





long __refs_ ; 

size_type __capacity_ ; 
size_type __nchars_ ; 
} ; 


template < class charT , class traits , class Allocator > 
class __string_ref : public __string_ref_rep < Allocator > 
{ 
public : 
typedef __string_ref_rep < Allocator > __string_ref_rep_type ; 
typedef typename __string_ref_rep < Allocator > :: size_type size_type ; 

__string_ref ( long initRef = 0 ) 
: __string_ref_rep < Allocator > ( initRef - 1 ) 
{ ; } 

__string_ref ( const __string_ref < charT , traits , Allocator > & ref ) 
: __string_ref_rep < Allocator > ( ref . __refs_ ) 
{ ; } 

private : 
long __references ( ) const 
{ 
return __string_ref_rep < Allocator > :: __refs_ + 1 ; 
} 

void __setRefCount ( long r ) 
{ 
if ( this != std :: basic_string < charT , traits , Allocator > :: __getNullRep ( ) ) 
{ 
#213
this -> __refs_ = r - 1 ; 
} 
} 

void __addReference ( ) 
{ 
if ( this != std :: basic_string < charT , traits , Allocator > :: __getNullRep ( ) ) 
{ 
#230
this -> __refs_ ++ ; 
} 
} 
long __removeReference ( ) 
{ 
if ( this != std :: basic_string < charT , traits , Allocator > :: __getNullRep ( ) ) 
{ 
#246
return __unSafeRemoveReference ( ) ; 
} 
else 
return 1 ; 
} 
long __unSafeRemoveReference ( ) 
{ 
if ( this != std :: basic_string < charT , traits , Allocator > :: __getNullRep ( ) ) 
{ 
this -> __refs_ -- ; 
return this -> __refs_ + 1 ; 
} 
else 
return 1 ; 
} 

size_type length ( ) const 
{ return __string_ref_rep < Allocator > :: __nchars_ ; } 
size_type __getCapac ( ) const 
{ return __string_ref_rep < Allocator > :: __capacity_ ; } 

charT * data ( ) const 
{ 
return ( charT * ) ( this + 1 ) ; 
} 
charT & operator [ ] ( size_type i ) 
{ 
return ( reinterpret_cast < charT * > ( ( this + 1 ) ) ) [ i ] ; 
} 
const charT & operator [ ] ( size_type i ) const 
{ 
return ( ( charT * ) ( this + 1 ) ) [ i ] ; 
} 

friend class std :: basic_string < charT , traits , Allocator > ; 



} ; 
#294
template < class charT , class traits , class Allocator , 
class stringRef = __string_ref_rep < Allocator > > 
struct __null_string_ref_rep 
{ 



stringRef __ref_hdr_ ; 
charT __eos_char_ ; 

__null_string_ref_rep ( ) 
: __ref_hdr_ ( 1 ) , __eos_char_ ( charT ( 0 ) ) { ; } 
__null_string_ref_rep ( const __null_string_ref_rep < charT , traits , 
Allocator , stringRef > & r ) 
: __ref_hdr_ ( r . __ref_hdr_ ) , __eos_char_ ( charT ( 0 ) ) { ; } 

} ; 


} 
#85 "/opt/SUNWspro/SC5.0/include/CC/./string"
namespace __rwstd { 





extern const unsigned int __rwse_InvalidSizeParam ; 
extern const unsigned int __rwse_PosBeyondEndOfString ; 
extern const unsigned int __rwse_ResultLenInvalid ; 
extern const unsigned int __rwse_StringIndexOutOfRange ; 
extern const unsigned int __rwse_UnexpectedNullPtr ; 
#111
} namespace std { 


template < class charT , class traits , class Allocator > 
class basic_string 
{ 
public : 
#127
typedef __rwstd :: __string_ref < charT , traits , Allocator > __string_ref_type ; 
#135
typedef typename __string_ref_type :: __string_ref_rep_type __rep_type ; 
#142
typedef __rwstd :: __null_string_ref_rep < charT , traits , Allocator , __rep_type > __null_ref_type ; 




typedef traits traits_type ; 
typedef typename traits :: char_type value_type ; 
typedef Allocator allocator_type ; 

private : 





typedef allocator_interface < Allocator , charT > __value_alloc_type ; 
typedef allocator_interface < Allocator , __string_ref_type > __ref_alloc_type ; 



public : 


typedef typename allocator_type :: size_type size_type ; 
typedef typename allocator_type :: difference_type difference_type ; 
typedef typename __value_alloc_type :: reference reference ; 
typedef typename __value_alloc_type :: const_reference const_reference ; 
typedef typename __value_alloc_type :: pointer pointer ; 
typedef typename __value_alloc_type :: const_pointer const_pointer ; 
typedef typename __value_alloc_type :: pointer iterator ; 
typedef typename __value_alloc_type :: const_pointer const_iterator ; 
#188
typedef std :: reverse_iterator < const_iterator , 
random_access_iterator_tag , value_type , 
const_reference , const_pointer , difference_type > 
const_reverse_iterator ; 
typedef std :: reverse_iterator < iterator , 
random_access_iterator_tag , value_type , 
reference , pointer , difference_type > 
reverse_iterator ; 





static const size_type npos ; 


inline basic_string ( const Allocator & = Allocator ( ) ) ; 





inline basic_string ( const basic_string < charT , traits , Allocator > & ) ; 
basic_string ( const basic_string < charT , traits , Allocator > & , 
size_type , size_type = npos , 
const Allocator & = Allocator ( ) ) ; 
basic_string ( const charT * , size_type , 
const Allocator & = Allocator ( ) ) ; 
basic_string ( const charT * , const Allocator & = Allocator ( ) ) ; 
#263
basic_string ( size_type n , charT c , const Allocator & alloc = Allocator ( ) ) 
: __data_ ( ( charT * ) 0 , alloc ) 
{ __initn ( n , c ) ; } 


basic_string ( const charT * , const charT * , const Allocator & = Allocator ( ) ) ; 




~ basic_string ( ) 
{ 
__unLink ( ) ; 
} 

basic_string < charT , traits , Allocator > & operator = ( const basic_string < charT , traits , Allocator > & ) ; 
basic_string < charT , traits , Allocator > & operator = ( const charT * ) ; 
inline basic_string < charT , traits , Allocator > & operator = ( charT ) ; 




iterator begin ( ) 
{ __cow ( ) ; __pref ( ) -> __setRefCount ( 0 ) ; return __data_ . data ( ) ; } 
const_iterator begin ( ) const 
{ return __data_ . data ( ) ; } 
iterator end ( ) 
{ __cow ( ) ; __pref ( ) -> __setRefCount ( 0 ) ; return __data_ . data ( ) + length ( ) ; } 
const_iterator end ( ) const 
{ return __data_ . data ( ) + length ( ) ; } 

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




size_type size ( ) const { return length ( ) ; } 
inline size_type length ( ) const ; 
size_type max_size ( ) const 
{ 
return npos - sizeof ( __rep_type ) - 2 ; 
} 
inline void resize ( size_type , charT ) ; 
void resize ( size_type n ) 
{ 
resize ( n , __eos ( ) ) ; 
} 
inline size_type capacity ( ) const ; 
inline void reserve ( size_type = 0 ) ; 
void clear ( ) { erase ( ) ; } 
bool empty ( ) const { return length ( ) == 0 ; } 




inline const_reference operator [ ] ( size_type ) const ; 
inline reference operator [ ] ( size_type ) ; 
inline const_reference at ( size_type ) const ; 
inline reference at ( size_type ) ; 




inline basic_string < charT , traits , Allocator > & operator += ( const basic_string < charT , traits , Allocator > & ) 
#333
; 
inline basic_string < charT , traits , Allocator > & operator += ( const charT * ) ; 
inline basic_string < charT , traits , Allocator > & operator += ( charT ) ; 

basic_string < charT , traits , Allocator > & append ( 
const basic_string < charT , traits , Allocator > & ) ; 
basic_string < charT , traits , Allocator > & append ( 
const basic_string < charT , traits , Allocator > & , 
size_type , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & append ( const charT * , size_type ) ; 
inline basic_string < charT , traits , Allocator > & append ( const charT * ) ; 
#375
inline basic_string < charT , traits , Allocator > & append ( const charT * , 
const charT * ) ; 
inline basic_string < charT , traits , Allocator > & append ( size_type , charT ) ; 


inline void push_back ( const charT ) ; 

basic_string < charT , traits , Allocator > & assign ( 
const basic_string < charT , traits , Allocator > & ) ; 
basic_string < charT , traits , Allocator > & assign ( 
const basic_string < charT , traits , Allocator > & , 
size_type , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & assign ( const charT * , size_type ) ; 
inline basic_string < charT , traits , Allocator > & assign ( const charT * ) ; 
#421
inline basic_string < charT , traits , Allocator > & assign ( const charT * , 
const charT * ) ; 
inline basic_string < charT , traits , Allocator > & assign ( size_type , charT ) ; 


basic_string < charT , traits , Allocator > & insert ( size_type , 
const basic_string < charT , traits , Allocator > & ) ; 
basic_string < charT , traits , Allocator > & insert ( 
size_type , 
const basic_string < charT , traits , Allocator > & , 
size_type , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & insert ( 
size_type , 
const charT * , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & insert ( size_type , const charT * ) ; 
iterator insert ( iterator pos , charT c ) 
{ 
iterator tmp = __replace_aux ( pos - begin ( ) , 0 , basic_string < charT , traits , Allocator > ( 1 , c ) ) ; 
__pref ( ) -> __setRefCount ( 0 ) ; 
return tmp ; 
} 
#494
inline void insert ( iterator , const charT * , const charT * ) ; 
inline basic_string < charT , traits , Allocator > & insert ( size_type , size_type , charT ) ; 
inline void insert ( iterator , size_type , charT ) ; 


inline basic_string < charT , traits , Allocator > & erase ( size_type = 0 , 
size_type = npos ) ; 

iterator erase ( iterator it ) 
{ 
iterator ret = replace ( it - begin ( ) , 1 , ( const charT * ) 0 , 0 , 0 , 0 ) ; 
__pref ( ) -> __setRefCount ( 0 ) ; 
return ret ; 
} 
iterator erase ( iterator first , iterator last ) 
{ 
iterator ret = replace ( first - begin ( ) , last - first , ( const charT * ) 0 , 0 , 0 , 0 ) ; 
__pref ( ) -> __setRefCount ( 0 ) ; 
return ret ; 
} 


private : 



typename 
basic_string < charT , traits , Allocator > :: iterator replace ( size_type , 
size_type , 
const charT * , 
size_type , 
size_type , 
size_type ) ; 

typename 
basic_string < charT , traits , Allocator > :: iterator __replace_aux ( 
size_type , 
size_type , 
const basic_string < charT , traits , Allocator > & , 
size_type = 0 , 
size_type = npos ) ; 
#545
public : 
inline basic_string < charT , traits , Allocator > & replace ( size_type , 
size_type , 
const basic_string < charT , traits , Allocator > & ) ; 
inline basic_string < charT , traits , Allocator > & replace ( size_type , 
size_type , 
const basic_string < charT , traits , Allocator > & , 
size_type , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & replace ( size_type , 
size_type , 
const charT * , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & replace ( size_type , 
size_type , 
const charT * ) ; 
basic_string < charT , traits , Allocator > & replace ( size_type , 
size_type , 
size_type , 
charT ) ; 
inline basic_string < charT , traits , Allocator > & replace ( iterator , 
iterator , 
const basic_string < charT , traits , Allocator > & ) ; 
inline basic_string < charT , traits , Allocator > & replace ( iterator , 
iterator , 
const charT * , 
size_type ) ; 
inline basic_string < charT , traits , Allocator > & replace ( iterator , 
iterator , 
const charT * ) ; 
#636
inline basic_string < charT , traits , Allocator > & replace ( iterator , iterator , 
const charT * , 
const charT * ) ; 
inline basic_string < charT , traits , Allocator > & replace ( iterator , 
iterator , 
size_type , 
charT ) ; 


size_type copy ( charT * , size_type , size_type = 0 ) const ; 
basic_string < charT , traits , Allocator > copy ( ) const ; 
void swap ( basic_string < charT , traits , Allocator > & s ) 
{ 
charT * temp = __data_ . data ( ) ; __data_ = s . __data_ . data ( ) ; s . __data_ = temp ; 
} 




inline const charT * c_str ( ) const ; 
inline const charT * data ( ) const ; 
allocator_type get_allocator ( ) const 
{ 
return ( allocator_type ) __data_ ; 
} 

inline size_type find ( const basic_string < charT , traits , Allocator > & , 
size_type = 0 ) const ; 
size_type find ( const charT * , size_type , size_type ) const ; 
inline size_type find ( const charT * , size_type = 0 ) const ; 
inline size_type find ( charT , size_type = 0 ) const ; 

inline size_type rfind ( const basic_string < charT , traits , Allocator > & , 
size_type = npos ) const ; 
size_type rfind ( const charT * , size_type , size_type ) const ; 
inline size_type rfind ( const charT * , size_type = npos ) const ; 
inline size_type rfind ( charT , size_type = npos ) const ; 

inline size_type find_first_of ( const basic_string < charT , traits , Allocator > & , 
size_type = 0 ) const ; 
size_type find_first_of ( const charT * , size_type , size_type ) const ; 
inline size_type find_first_of ( const charT * , size_type = 0 ) const ; 
inline size_type find_first_of ( charT , size_type = 0 ) const ; 
inline size_type find_last_of ( const basic_string < charT , traits , Allocator > & , 
size_type = npos ) const ; 
size_type find_last_of ( const charT * , size_type , size_type ) const ; 
inline size_type find_last_of ( const charT * , size_type = npos ) const ; 
inline size_type find_last_of ( charT , size_type = npos ) const ; 

inline size_type find_first_not_of ( const basic_string < charT , traits , Allocator > & , 
size_type = 0 ) const ; 
size_type find_first_not_of ( const charT * , size_type , 
size_type ) const ; 
inline size_type find_first_not_of ( const charT * , size_type = 0 ) const ; 
inline size_type find_first_not_of ( charT , size_type = 0 ) const ; 

inline size_type find_last_not_of ( const basic_string < charT , traits , Allocator > & , 
size_type = npos ) const ; 
size_type find_last_not_of ( const charT * , size_type , size_type ) const ; 
inline size_type find_last_not_of ( const charT * , size_type = npos ) const ; 
inline size_type find_last_not_of ( charT , size_type = npos ) const ; 

basic_string < charT , traits , Allocator > substr ( size_type = 0 , 
size_type = npos ) const ; 

inline int compare ( const basic_string < charT , traits , Allocator > & ) const ; 
int compare ( size_type , size_type , 
const basic_string < charT , traits , Allocator > & ) const ; 
int compare ( size_type , size_type , 
const basic_string < charT , traits , Allocator > & , 
size_type , size_type ) const ; 
inline int compare ( const charT * ) const ; 
int compare ( size_type , size_type , const charT * , size_type ) const ; 
inline int compare ( size_type , size_type , const charT * ) const ; 

protected : 

size_type __getCapac ( ) const { return __pref ( ) -> __getCapac ( ) ; } 

void __clobber ( size_type ) ; 
void __cow ( ) 
{ 
if ( __pref ( ) -> __references ( ) > 1 ) 
__clone ( ) ; 
} 
void __cow ( size_type nc ) 
{ 
if ( __pref ( ) -> __references ( ) > 1 || __getCapac ( ) < nc ) 
__clone ( nc ) ; 
} 

private : 

void __initn ( size_type , charT ) ; 

static charT __eos ( ) { return ( charT ) 0 ; } 




void __clone ( ) ; 



void __clone ( size_type nc ) ; 

__string_ref_type * __pref ( ) const 
{ 



return 
static_cast < __string_ref_type * > ( ( ( reinterpret_cast < __string_ref_type * > ( __data_ . data ( ) ) ) - 1 ) ) ; 

} 




inline void __unLink ( ) ; 


friend class __rwstd :: __string_ref < charT , traits , Allocator > ; 
#767
static const __null_ref_type __nullref ; 


static __string_ref_type * __getNullRep ( ) 
{ 




return reinterpret_cast < __string_ref_type * > 
( const_cast < __null_ref_type * > ( & __nullref ) ) ; 
#787
} 
__string_ref_type * __getRep ( size_type capac , size_type nchar ) ; 

__rwstd :: __rw_basis < charT * , allocator_type > __data_ ; 
} ; 





typedef basic_string < char , char_traits < char > , allocator < char > > 
string ; 


typedef basic_string < wchar_t , char_traits < wchar_t > , allocator < wchar_t > > 
wstring ; 
#813
} 
#40 "/opt/SUNWspro/SC5.0/include/CC/./stdexcept"
namespace std { 
#50
class logic_error : public exception 
{ 
public : 
logic_error ( const string & what_arg ) throw ( ) 
: str_ ( what_arg ) 
{ ; } 

virtual ~ logic_error ( ) throw ( ) ; 

virtual const char * what ( ) const throw ( ) 
{ 
return str_ . data ( ) ; 
} 

private : 
string str_ ; 
} ; 


class domain_error : public logic_error 
{ 
public : 
domain_error ( const string & what_arg ) throw ( ) 

: logic_error ( what_arg ) { ; } 




virtual ~ domain_error ( ) throw ( ) ; 
} ; 

class invalid_argument : public logic_error 
{ 
public : 
invalid_argument ( const string & what_arg ) throw ( ) 

: logic_error ( what_arg ) { ; } 




virtual ~ invalid_argument ( ) throw ( ) ; 
} ; 

class length_error : public logic_error 
{ 
public : 
length_error ( const string & what_arg ) throw ( ) 

: logic_error ( what_arg ) { ; } 




virtual ~ length_error ( ) throw ( ) ; 
} ; 

class out_of_range : public logic_error 
{ 
public : 
out_of_range ( const string & what_arg ) throw ( ) 

: logic_error ( what_arg ) { ; } 




virtual ~ out_of_range ( ) throw ( ) ; 
} ; 

class runtime_error : public exception 
{ 
public : 
runtime_error ( const string & what_arg ) throw ( ) 
: str_ ( what_arg ) 
{ ; } 

virtual ~ runtime_error ( ) throw ( ) ; 

virtual const char * what ( ) const throw ( ) 
{ 
return str_ . data ( ) ; 
} 

private : 
string str_ ; 
} ; 

class range_error : public runtime_error 
{ 
public : 
range_error ( const string & what_arg ) throw ( ) 
: runtime_error ( what_arg ) { ; } 

virtual ~ range_error ( ) throw ( ) ; 
} ; 

class overflow_error : public runtime_error 
{ 
public : 
overflow_error ( const string & what_arg ) throw ( ) 
: runtime_error ( what_arg ) { ; } 

virtual ~ overflow_error ( ) throw ( ) ; 
} ; 

class underflow_error : public runtime_error 
{ 
public : 
underflow_error ( const string & what_arg ) throw ( ) 
: runtime_error ( what_arg ) { ; } 

virtual ~ underflow_error ( ) throw ( ) ; 
} ; 


} 
#843 "/opt/SUNWspro/SC5.0/include/CC/./string"
namespace std { 
#850
template < class charT , class traits , class Allocator > 
inline void basic_string < charT , traits , Allocator > :: __unLink ( ) 
{ 
if ( ! __data_ . data ( ) ) 
return ; 
if ( __pref ( ) -> __references ( ) == 0 || __pref ( ) -> __removeReference ( ) == 0 ) 
{ 
__ref_alloc_type ( __data_ ) . destroy ( __pref ( ) ) ; 
__value_alloc_type ( __data_ ) . 
deallocate ( reinterpret_cast < charT * > ( __pref ( ) ) , length ( ) ) ; 
__data_ = ( charT * ) 0 ; 
} 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > 
:: basic_string ( const Allocator & alloc ) : __data_ ( ( charT * ) 0 , alloc ) 
{ 
__data_ = __getNullRep ( ) -> data ( ) ; 
__getNullRep ( ) -> __addReference ( ) ; 
} 
#882
template < class charT , class traits , class Allocator > 
inline 
basic_string < charT , traits , Allocator > 
:: basic_string ( const basic_string < charT , traits , Allocator > & s ) 
: __data_ ( ( charT * ) 0 , Allocator ( ) ) 
{ 
if ( s . __pref ( ) -> __references ( ) > 0 ) 
{ 
__data_ = s . __data_ . data ( ) ; 
__pref ( ) -> __addReference ( ) ; 
} 
else 
{ 
size_type n = s . length ( ) ; 
__data_ = __getRep ( n , n ) -> data ( ) ; 
traits :: copy ( __data_ . data ( ) , s . c_str ( ) , n ) ; 
} 
} 


template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: operator = ( charT c ) 
{ 
replace ( 0 , length ( ) , 1 , c ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: operator += ( const basic_string < charT , traits , Allocator > & s ) 
{ 
return append ( s ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: operator += ( const charT * s ) 
{ 
return append ( s ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: operator += ( charT c ) 
{ 
return append ( ( size_type ) 1 , c ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: append ( const charT * s , size_type n ) 
{ 
replace ( size ( ) , 0 , s , n , 0 , n ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: append ( const charT * s ) 
{ 
replace ( size ( ) , 0 , s ) ; 
return * this ; 
} 
#958
template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: append ( const charT * first , 
const charT * last ) 
{ 
replace ( size ( ) , 0 , first , last - first , 0 , last - first ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: append ( size_type n , charT c ) 
{ 
replace ( length ( ) , 0 , n , c ) ; 
return * this ; 
} 


template < class charT , class traits , class Allocator > 
void basic_string < charT , traits , Allocator > :: push_back ( const charT c ) 
{ 
replace ( size ( ) , 0 , 1 , c ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: assign ( const charT * s , size_type n ) 
{ 
replace ( 0 , length ( ) , s , n , 0 , n ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: assign ( const charT * s ) 
{ 
size_type len = traits :: length ( s ) ; 
replace ( 0 , length ( ) , s , len , 0 , len ) ; 
return * this ; 
} 
#1010
template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: assign ( const charT * first , 
const charT * last ) 
{ 
replace ( 0 , length ( ) , first , last - first , 0 , last - first ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: assign ( size_type n , charT c ) 
{ 
return replace ( 0 , length ( ) , n , c ) ; 
} 


template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: insert ( size_type pos , 
const charT * s , 
size_type n ) 
{ 
replace ( pos , 0 , s , n , 0 , n ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: insert ( size_type pos , const charT * s ) 
{ 
size_type len = traits :: length ( s ) ; 
replace ( pos , 0 , s , len , 0 , len ) ; 
return * this ; 
} 
#1058
template < class charT , class traits , class Allocator > 
inline void 
basic_string < charT , traits , Allocator > :: insert ( 
iterator p , 
const charT * first , 
const charT * last ) 
{ 
replace ( p - begin ( ) , 0 , first , last - first , 0 , last - first ) ; 
} 

template < class charT , class traits , class Allocator > 
inline void 
basic_string < charT , traits , Allocator > :: insert ( 
iterator p , 
size_type n , 
charT c ) 
{ 
replace ( p - begin ( ) , 0 , n , c ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: insert ( size_type pos , 
size_type n , 
charT c ) 
{ 
return replace ( pos , 0 , n , c ) ; 
} 


template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: erase ( size_type pos , size_type n ) 
{ 


if ( pos > length ( ) ) throw out_of_range ( __rwstd :: except_msg_string ( __rwstd :: __rwse_StringIndexOutOfRange , "basic_string::erase(size_t,size_t)" 
#1094
, pos , length ( ) ) . msgstr ( ) ) ; 

size_type len = length ( ) - pos ; 
charT tmp [ 1 ] ; 
* tmp = 0 ; 
return replace ( pos , n < len ? n : len , tmp , 0 ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( size_type pos1 , 
size_type n1 , 
const basic_string < charT , traits , Allocator > & str , 
size_type pos2 , 
size_type n2 ) 
{ 
replace ( pos1 , n1 , str . data ( ) , str . length ( ) , pos2 , n2 ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( 
size_type pos1 , 
size_type n1 , 
const basic_string < charT , traits , Allocator > & str ) 
{ 
replace ( pos1 , n1 , str . data ( ) , str . length ( ) , 0 , str . length ( ) ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: iterator 
basic_string < charT , traits , Allocator > :: __replace_aux ( size_type pos1 , 
size_type n1 , 
const basic_string < charT , traits , Allocator > & str , 
size_type pos2 , 
size_type n2 ) 
{ 
return replace ( pos1 , n1 , str . data ( ) , str . length ( ) , pos2 , n2 ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( size_type pos , 
size_type n1 , 
const charT * s , 
size_type n2 ) 
{ 
replace ( pos , n1 , s , n2 , 0 , n2 ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( size_type pos , 
size_type n1 , 
const charT * s ) 
{ 
size_type len = traits :: length ( s ) ; 
replace ( pos , n1 , s , len , 0 , len ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( 
iterator first , 
iterator last , 
const basic_string < charT , traits , Allocator > & str ) 
{ 
return replace ( first - begin ( ) , last - first , str ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( 
iterator first , 
iterator last , 
const charT * s , 
size_type n ) 
{ 
replace ( first - begin ( ) , last - first , s , n , 0 , n ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( 
iterator first , 
iterator last , 
const charT * s ) 
{ 
size_type len = traits :: length ( s ) ; 
replace ( first - begin ( ) , last - first , s , len , 0 , len ) ; 
return * this ; 
} 



template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( 
iterator first1 , 
iterator last1 , 
const charT * first2 , 
const charT * last2 ) 
{ 
replace ( first1 - begin ( ) , last1 - first1 , first2 , last2 - first2 , 0 , last2 - first2 ) ; 
return * this ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > & 
basic_string < charT , traits , Allocator > :: replace ( 
iterator first , 
iterator last , 
size_type n , 
charT c ) 
{ 
return replace ( first - begin ( ) , last - first , n , c ) ; 
} 


template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: const_reference 
basic_string < charT , traits , Allocator > :: operator [ ] ( size_type pos ) const 
{ 





return __data_ . data ( ) [ pos ] ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: reference 
basic_string < charT , traits , Allocator > :: operator [ ] ( size_type pos ) 
{ 





__cow ( ) ; 
__pref ( ) -> __setRefCount ( 0 ) ; 
return __data_ . data ( ) [ pos ] ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: const_reference 
basic_string < charT , traits , Allocator > :: at ( size_type pos ) const 
{ 


if ( pos >= size ( ) ) throw out_of_range ( __rwstd :: except_msg_string ( __rwstd :: __rwse_PosBeyondEndOfString , "basic_string::at(size_t) const" 
#1250
, pos , size ( ) ) . msgstr ( ) ) ; 

return __data_ . data ( ) [ pos ] ; 
} 


template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: reference 
basic_string < charT , traits , Allocator > :: at ( size_type pos ) 
{ 


if ( pos >= size ( ) ) throw out_of_range ( __rwstd :: except_msg_string ( __rwstd :: __rwse_PosBeyondEndOfString , "basic_string::at(size_t)" 
#1262
, pos , size ( ) ) . msgstr ( ) ) ; 

__cow ( ) ; 
__pref ( ) -> __setRefCount ( 0 ) ; 
return __data_ . data ( ) [ pos ] ; 
} 

template < class charT , class traits , class Allocator > 
inline const charT * basic_string < charT , traits , Allocator > :: c_str ( ) const 
{ 
return __data_ . data ( ) ; 
} 

template < class charT , class traits , class Allocator > 
inline const charT * basic_string < charT , traits , Allocator > :: data ( ) const 
{ 
return __data_ . data ( ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: length ( ) const 
{ 
return __pref ( ) -> __nchars_ ; 
} 

template < class charT , class traits , class Allocator > 
inline void 
basic_string < charT , traits , Allocator > :: resize ( size_type n , charT c ) 
{ 


if ( n > max_size ( ) ) throw length_error ( __rwstd :: except_msg_string ( __rwstd :: __rwse_InvalidSizeParam , "basic_string( const charT*,size_type,const Allocator&)" 
#1294
, n , npos ) . msgstr ( ) ) ; 
if ( n < length ( ) ) 
erase ( n , length ( ) - n ) ; 
else 
replace ( length ( ) , 0 , n - length ( ) , c ) ; 
__pref ( ) -> __setRefCount ( 1 ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: capacity ( ) const 
{ 
return __getCapac ( ) ; 
} 

template < class charT , class traits , class Allocator > 
inline void basic_string < charT , traits , Allocator > :: reserve ( size_type res_arg ) 
{ 


if ( res_arg > max_size ( ) ) throw length_error ( __rwstd :: except_msg_string ( __rwstd :: __rwse_InvalidSizeParam , "basic_string::reserve(size_t)" 
#1314
, res_arg , max_size ( ) ) . msgstr ( ) ) ; 

if ( res_arg > __getCapac ( ) ) __clone ( res_arg ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > 
basic_string < charT , traits , Allocator > :: copy ( ) const 
{ 
basic_string < charT , traits , Allocator > temp ( * this ) ; 
temp . __clone ( ) ; 
return temp ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find ( 
const basic_string < charT , traits , Allocator > & str , 
size_type pos ) const 
{ 
return find ( str . c_str ( ) , pos , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find ( const charT * s , 
size_type pos ) const 
{ 


if ( s == 0 ) throw logic_error ( __rwstd :: except_msg_string ( __rwstd :: __rwse_UnexpectedNullPtr , "basic_string::find(const char*,size_t) const" 
#1344
) . msgstr ( ) ) ; 

if ( pos > length ( ) ) 
return npos ; 
const charT * p = __rwstd :: rw_traits < charT , traits > :: find ( __data_ . data ( ) + pos , s ) ; 
return p ? p - __data_ . data ( ) : npos ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find ( charT c , size_type pos ) const 
{ 
if ( pos > length ( ) ) 
return npos ; 
const charT * p = traits :: find ( __data_ . data ( ) + pos , length ( ) - pos , c ) ; 
return p ? p - __data_ . data ( ) : npos ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: rfind ( 
const basic_string < charT , traits , Allocator > & str , 
size_type pos ) const 
{ 
return rfind ( str . c_str ( ) , pos , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: rfind ( const charT * s , size_type pos ) 
const 
{ 
size_type len = traits :: length ( s ) ; 
return rfind ( s , pos , len ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: rfind ( charT c , size_type pos ) const 
{ 
if ( pos > length ( ) ) 
pos = length ( ) ; 
const charT * p = __rwstd :: rw_traits < charT , traits > :: rfind ( __data_ . data ( ) , c , pos ) ; 
return p ? p - __data_ . data ( ) : npos ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_first_of ( 
const basic_string < charT , traits , Allocator > & str , 
size_type pos ) const 
{ 
return find_first_of ( str . c_str ( ) , pos , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_first_of ( const charT * s , 
size_type pos ) const 
{ 


if ( s == 0 ) throw logic_error ( __rwstd :: except_msg_string ( __rwstd :: __rwse_UnexpectedNullPtr , "basic_string::find_first_of(char*,size_t) const" 
#1406
) . msgstr ( ) ) ; 

if ( pos > length ( ) ) 
return npos ; 
size_type i = __rwstd :: rw_traits < charT , traits > :: find_first_of ( __data_ . data ( ) + pos , s ) + pos ; 
return i >= length ( ) ? npos : i ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_first_of ( charT c , size_type pos ) const 
{ 
return find ( c , pos ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_last_of ( 
const basic_string < charT , traits , Allocator > & str , 
size_type pos ) const 
{ 
return find_last_of ( str . c_str ( ) , pos , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_last_of ( const charT * s , 
size_type pos ) const 
{ 
size_type len = traits :: length ( s ) ; 
return find_last_of ( s , pos , len ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_last_of ( charT c , size_type pos ) 
const 
{ 
return rfind ( c , pos ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_first_not_of ( 
const basic_string < charT , traits , Allocator > & str , 
size_type pos ) const 
{ 
return find_first_not_of ( str . c_str ( ) , pos , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_first_not_of ( const charT * s , 
size_type pos ) const 
{ 


if ( s == 0 ) throw logic_error ( __rwstd :: except_msg_string ( __rwstd :: __rwse_UnexpectedNullPtr , "basic_string::find_first_not_of(char*,size_t) const" 
#1463
) . msgstr ( ) ) ; 

if ( pos > length ( ) ) 
return npos ; 
size_type i = __rwstd :: rw_traits < charT , traits > :: find_first_not_of ( __data_ . data ( ) + pos , s ) + pos ; 
return i >= length ( ) ? npos : i ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_first_not_of ( charT c , 
size_type pos ) const 
{ 
charT tmp [ 2 ] ; 
* tmp = c ; 
tmp [ 1 ] = 0 ; 
return find_first_not_of ( tmp , pos ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_last_not_of ( 
const basic_string < charT , traits , Allocator > & str , 
size_type pos ) const 
{ 
return find_last_not_of ( str . c_str ( ) , pos , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_last_not_of ( const charT * s , 
size_type pos ) const 
{ 
size_type len = traits :: length ( s ) ; 
return find_last_not_of ( s , pos , len ) ; 
} 

template < class charT , class traits , class Allocator > 
inline typename basic_string < charT , traits , Allocator > :: size_type 
basic_string < charT , traits , Allocator > :: find_last_not_of ( charT c , 
size_type pos ) const 
{ 
charT tmp [ 2 ] ; 
* tmp = c ; 
tmp [ 1 ] = 0 ; 
return find_last_not_of ( tmp , pos ) ; 
} 

template < class charT , class traits , class Allocator > 
inline int 
basic_string < charT , traits , Allocator > :: compare ( 
const basic_string < charT , traits , Allocator > & str ) const 
{ 
return compare ( 0 , length ( ) , str . c_str ( ) , str . length ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline int 
basic_string < charT , traits , Allocator > :: compare ( size_type pos , 
size_type n1 , 
const charT * s ) const 
{ 
size_type len = traits :: length ( s ) ; 
return compare ( pos , n1 , s , len ) ; 
} 

template < class charT , class traits , class Allocator > 
inline int 
basic_string < charT , traits , Allocator > :: compare ( const charT * s ) const 
{ 
size_type len = traits :: length ( s ) ; 
return compare ( 0 , length ( ) , s , len ) ; 
} 





template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > operator + ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . append ( rhs ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > operator + ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . append ( rhs ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > operator + ( 
charT lhs , const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( 1 , lhs ) . append ( rhs ) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > operator + ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . append ( basic_string < charT , traits , Allocator > ( rhs ) 
#1569
) ; 
} 

template < class charT , class traits , class Allocator > 
inline basic_string < charT , traits , Allocator > operator + ( 
const basic_string < charT , traits , Allocator > & lhs , 
charT rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . append ( basic_string < charT , traits , Allocator > ( 1 , rhs 
#1577
) ) ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator == ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return lhs . compare ( rhs ) == 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator == ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . compare ( rhs ) == 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator == ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return lhs . compare ( basic_string < charT , traits , Allocator > ( rhs ) ) == 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator < ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return lhs . compare ( rhs ) < 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator < ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . compare ( rhs ) < 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator < ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return lhs . compare ( basic_string < charT , traits , Allocator > ( rhs ) ) < 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator != ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return lhs . compare ( rhs ) != 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator != ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . compare ( rhs ) != 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator != ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return lhs . compare ( basic_string < charT , traits , Allocator > ( rhs ) ) != 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator > ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return lhs . compare ( rhs ) > 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator > ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . compare ( rhs ) > 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator > ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return lhs . compare ( basic_string < charT , traits , Allocator > ( rhs ) ) > 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator <= ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return lhs . compare ( rhs ) <= 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator <= ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . compare ( rhs ) <= 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator <= ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return lhs . compare ( basic_string < charT , traits , Allocator > ( rhs ) ) <= 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator >= ( 
const basic_string < charT , traits , Allocator > & lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return lhs . compare ( rhs ) >= 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline bool operator >= ( 
const charT * lhs , 
const basic_string < charT , traits , Allocator > & rhs ) 
{ 
return basic_string < charT , traits , Allocator > ( lhs ) . compare ( rhs ) >= 0 ? true : false ; 
} 

template < class charT , class traits , class Allocator > 
inline bool operator >= ( 
const basic_string < charT , traits , Allocator > & lhs , 
const charT * rhs ) 
{ 
return lhs . compare ( basic_string < charT , traits , Allocator > ( rhs ) ) >= 0 ? true : false ; 
} 


template < class charT , class traits , class Allocator > 
inline void swap ( basic_string < charT , traits , Allocator > & a , 
basic_string < charT , traits , Allocator > & b ) 
{ 
a . swap ( b ) ; 
} 
#1767
} 
#16 "/opt/SUNWspro/SC5.0/include/CC/./typeinfo"
namespace __Cimpl { 
class __type_info_friend ; 
} 

namespace std { 

class type_info { 
public : 
virtual ~ type_info ( ) ; 
virtual bool operator == ( const type_info & rhs ) const ; 
virtual bool operator != ( const type_info & rhs ) const ; 
virtual bool before ( const type_info & rhs ) const ; 
const char * name ( ) const ; 

private : 
type_info ( const type_info & ) ; 
type_info & operator = ( const type_info & ) ; 


const void * __data ; 
type_info ( const void * ) throw ( ) ; 
friend __Cimpl :: __type_info_friend ; 
} ; 

class bad_typeid : public exception { 
public : 
bad_typeid ( ) throw ( ) { } 
bad_typeid ( const bad_typeid & ) throw ( ) { } 
bad_typeid & operator = ( const bad_typeid & ) throw ( ) { return * this ; } 
~ bad_typeid ( ) throw ( ) { } 
const char * what ( ) const throw ( ) ; 
} ; 

class bad_cast : public exception { 
public : 
bad_cast ( ) throw ( ) { } 
bad_cast ( const bad_cast & ) throw ( ) { } 
bad_cast & operator = ( const bad_cast & ) throw ( ) { return * this ; } 
~ bad_cast ( ) throw ( ) { } 
const char * what ( ) const throw ( ) ; 
} ; 


} 
#74 "/opt/SUNWspro/SC5.0/include/CC/rw/rwlocale"
namespace __rwstd { 



extern const unsigned int __rw_LocaleNotPresent ; 





} namespace std { 





class locale ; 
#97
template < class Facet > 
inline const Facet & use_facet ( const locale & , Facet * ) ; 
template < class Facet > 
inline bool has_facet ( const locale & , Facet * ) throw ( ) ; 


template < class charT > inline bool isspace ( charT c , const locale & ) ; 
template < class charT > inline bool isprint ( charT c , const locale & ) ; 
template < class charT > inline bool iscntrl ( charT c , const locale & ) ; 
template < class charT > inline bool isupper ( charT c , const locale & ) ; 
template < class charT > inline bool islower ( charT c , const locale & ) ; 
template < class charT > inline bool isalpha ( charT c , const locale & ) ; 
template < class charT > inline bool isdigit ( charT c , const locale & ) ; 
template < class charT > inline bool ispunct ( charT c , const locale & ) ; 
template < class charT > inline bool isxdigit ( charT c , const locale & ) ; 
template < class charT > inline bool isalnum ( charT c , const locale & ) ; 
template < class charT > inline bool isgraph ( charT c , const locale & ) ; 

template < class charT > inline charT toupper ( charT c , const locale & ) ; 
template < class charT > inline charT tolower ( charT c , const locale & ) ; 

class ctype_base ; 
template < class charT > class ctype ; 
template < > class ctype < char > ; 
template < class charT > class ctype_byname ; 
template < > class ctype_byname < char > ; 
class codecvt_base ; 
template < class internT , class externT , class stateT > class codecvt ; 
template < > class codecvt < char , char , mbstate_t > ; 


template < > class ctype < wchar_t > ; 
template < > class ctype_byname < wchar_t > ; 
template < > class codecvt < wchar_t , char , mbstate_t > ; 


template < class internT , class externT , class stateT > class codecvt_byname ; 

template < class charT , 
class InputIterator = istreambuf_iterator < charT > > 
class num_get ; 
template < class charT , 
class OutputIterator = ostreambuf_iterator < charT > > 
class num_put ; 
template < class charT > class numpunct ; 
template < class charT > class numpunct_byname ; 

template < class charT > class collate ; 
template < class charT > class collate_byname ; 

class time_base ; 
template < class charT , 
class InputIterator = istreambuf_iterator < charT > > 
class time_get ; 
template < class charT , 
class InputIterator = istreambuf_iterator < charT > > 
class time_get_byname ; 
template < class charT , 
class OutputIterator = ostreambuf_iterator < charT > > 
class time_put ; 
template < class charT , 
class OutputIterator = ostreambuf_iterator < charT > > 
class time_put_byname ; 

class money_base ; 
template < class charT , 
class InputIterator = istreambuf_iterator < charT > > 
class money_get ; 
template < class charT , 
class OutputIterator = ostreambuf_iterator < charT > > 
class money_put ; 
template < class charT , bool Intl = false > 
class moneypunct ; 
template < class charT , bool Intl = false > 
class moneypunct_byname ; 

class messages_base ; 
template < class charT > class messages ; 
template < class charT > class messages_byname ; 
#230
} 
#57 "/opt/SUNWspro/SC5.0/include/CC/rw/locimpl"
namespace __rwstd { 
using std :: use_facet ; 
using std :: locale ; 
#68
template < class charT > class timepunct ; 
#83
class locale_imp ; 
class facet_imp ; 

class digit_map_base ; 
template < class charT > class digit_map ; 
template < class charT > class keyword_def ; 
template < class charT > class keyword_map ; 
template < class charT > class keyword_cracker ; 

class digit_reader_base ; 
template < class charT > class digit_reader_base_1 ; 
template < class charT , class InputIterator > 
class digit_reader ; 

class digit_writer_base ; 
template < class charT > 
class digit_writer_base_1 ; 
template < class charT , class OutputIterator > 
class digit_writer ; 
#110
class ref_counted { 
friend class std :: locale ; 

size_t __ref_count ; 

_RWSTDMutex __mutex ; 


protected : 
ref_counted ( size_t initial_refs ) : 
__ref_count ( initial_refs ) { } 


virtual ~ ref_counted ( void ) ; 




static void add_reference ( ref_counted * ob ) { 
_RWSTDGuard ( ob -> __mutex ) ; 
++ ob -> __ref_count ; 
} 

static void remove_reference ( ref_counted * ob ) { 
size_t refs ; 
{ 
_RWSTDGuard ( ob -> __mutex ) ; 
refs = -- ob -> __ref_count ; 
} 
if ( ! refs ) 
delete ob ; 
} 

static void add_possible_reference ( ref_counted * ob ) { 
if ( ob ) 
add_reference ( ob ) ; 
} 

static void remove_possible_reference ( ref_counted * ob ) { 
if ( ob ) 
remove_reference ( ob ) ; 
} 
} ; 
#163
class locale_id_imp { 
protected : 
mutable size_t __id_value ; 
static size_t __last_used_id ; 

locale_id_imp ( ) : __id_value ( 0 ) { ; } 


static _RWSTDMutex __mutex ; 


void __initid ( ) const ; 
} ; 





class facet_imp : public ref_counted 
{ 
public : 
friend class locale_imp ; 
friend class std :: locale ; 
public : 
enum { 
__facet_cat = 0 , 
__ok_implicit = 0 , 
__initdone = 1 
} ; 

private : 
int __flags ; 
int __category ; 

protected : 
facet_imp ( size_t refs , int cat = 0 ) : 
ref_counted ( refs ) , __flags ( 0 ) , __category ( cat ) { } 





virtual void __initfacet ( const locale * ) { } 
} ; 


} 
#32 "/opt/SUNWspro/SC5.0/include/CC/rw/locvector"
namespace __rwstd { 
#41
template < class T > 
class locale_vector 
{ 
public : 
typedef size_t size_type ; 
typedef ptrdiff_t difference_type ; 
typedef T value_type ; 
typedef T & reference ; 
typedef T * pointer ; 
typedef T * iterator ; 

private : 
iterator first_ ; 
size_type size_ ; 

public : 
locale_vector ( ) : first_ ( 0 ) , size_ ( 0 ) { ; } 
locale_vector ( size_type n ) : first_ ( 0 ) , size_ ( n ) 
{ 
if ( n ) 
first_ = new T [ n ] ; 
} 
locale_vector ( size_type n , const T & v ) : first_ ( 0 ) , size_ ( n ) 
{ 
if ( n ) 
first_ = new T [ n ] ; 
while ( n ) 
first_ [ -- n ] = v ; 
} 
locale_vector ( const locale_vector < T > & lv ) : first_ ( 0 ) , size_ ( 0 ) 
{ 
size_type n = size_ = lv . size ( ) ; 
if ( n ) 
first_ = new T [ n ] ; 
while ( n -- ) 
first_ [ n ] = lv [ n ] ; 
} 
~ locale_vector ( ) { if ( first_ ) delete [ ] first_ ; } 
const locale_vector & operator = ( const locale_vector & lv ) 
{ 
size_type n = size_ = lv . size ( ) ; 
if ( first_ ) 
delete [ ] first_ ; 
if ( n ) 
first_ = new T [ n ] ; 
while ( n -- ) 
first_ [ n ] = lv [ n ] ; 
return * this ; 
} 
iterator begin ( ) const { return iterator ( first_ ) ; } 
iterator end ( ) const { return iterator ( first_ + size_ ) ; } 
size_type size ( ) const { return size_ ; } 

T & operator [ ] ( size_t i ) { return first_ [ i ] ; } 
const T & operator [ ] ( size_t i ) const { return first_ [ i ] ; } 


iterator resize ( size_t s ) 
{ 
return resize ( s , T ( ) ) ; 
} 
iterator resize ( size_t s , T v ) 
{ 
T * new_buf = new T [ s ] ; 
iterator j , k ; 
size_type d = size_ < s ? size_ : s ; 

for ( j = first_ , k = new_buf ; j != first_ + d ; j ++ , k ++ ) 
* k = * j ; 

while ( d < s ) 
new_buf [ d ++ ] = v ; 

if ( first_ ) 
delete [ ] first_ ; 
first_ = new_buf ; 
size_ = s ; 
return first_ ; 
} 
} ; 


} 
#215 "/opt/SUNWspro/SC5.0/include/CC/rw/locimpl"
namespace __rwstd { 
#222
class locale_imp : public ref_counted 
{ 
public : 
friend class std :: locale ; 


typedef int locale_category ; 
locale_vector < std :: string > names_ ; 
locale_vector < facet_imp * > vec_ ; 

locale_category native_cats_ ; 
locale_category named_cats_ ; 
std :: string big_name_ ; 
bool named_ ; 

locale_imp ( size_t sz = 36 , size_t refs = 0 ) ; 
locale_imp ( const locale_imp & , size_t refs ) ; 
~ locale_imp ( ) ; 

public : 
inline facet_imp * get_facet ( size_t i ) const 
{ return i < vec_ . size ( ) ? vec_ [ i ] : 0 ; } 

private : 
const char * category_name ( locale_category ) const ; 


static locale_category map_category ( locale_category ) ; 


static bool parse_name ( locale_vector < std :: string > & , const char * ) ; 


static std :: string clean_name ( std :: string s ) 
{ 



return s ; 

} 


static bool build_name ( std :: string & , const locale_vector < std :: string > & ) ; 
} ; 
#275
struct digit_map_base { 
enum { zero , minus , plus , X , x , E , e } ; 
static const char punct_chars [ 7 ] ; 
static const char digit_chars [ 22 ] ; 
static const char char_values [ 22 ] ; 
} ; 
#297
template < > 
class digit_map < char > : 
public digit_map_base 
{ 
public : 
typedef char char_type ; 

bool is_inited ( void ) const { return true ; } 
const char * get_punct ( void ) const { return punct_chars ; } 
inline int eval ( char c ) const ; 
static inline const digit_map < char > & 
get_digit_map ( const std :: ctype < char > & ) ; 
} ; 
#316
inline int digit_map < char > :: eval ( char c ) const { 
int num = c ; 
if ( ( num -= '0' ) > 9 ) { 
if ( ( ( num -= ( 'A' - '0' ) ) > 5 && ( num -= ( 'a' - 'A' ) ) > 5 ) || ( num += 10 ) < 10 ) 
num = - 1 ; 
} 
return num ; 
} 

template < class charT > 
class digit_map : 
public digit_map_base 
{ 
bool inited ; 
charT punct_array [ 7 ] ; 
charT digit_array [ 22 ] ; 
char value_array [ 22 ] ; 
public : 
typedef charT char_type ; 

digit_map ( void ) : inited ( false ) { } 
bool is_inited ( void ) const { return inited ; } 
void init ( const std :: ctype < charT > & ct ) ; 
const charT * get_punct ( void ) const { return punct_array ; } 
int eval ( charT ) const ; 



static inline const digit_map < charT > & 
get_digit_map ( const std :: ctype < charT > & ct ) 
{ 
if ( ! ct . __digit_map . inited ) 
( const_cast < digit_map < char_type > & > ( ct . __digit_map ) ) 
. init ( ct ) ; 
return ct . __digit_map ; 
} 
} ; 
#361
template < class charT > 
class keyword_def { 
public : 
const charT * s ; 
int v ; 
} ; 
#376
template < class charT > 
class keyword_map { 
public : 
int num_defs_ ; 
const keyword_def < charT > * defs_ ; 
} ; 
#389
template < class charT > 
class punct_data { 
friend class digit_reader_base_1 < charT > ; 
friend class digit_writer_base_1 < charT > ; 
public : 
typedef std :: basic_string < charT , std :: char_traits < charT > , std :: allocator < charT > > string_type ; 
protected : 
charT dp_ , ts_ ; 
std :: string gr_ ; 
} ; 
#420
template < class Facet > 
inline Facet * create_named_facet 
( Facet * , const char * , size_t refs ) ; 

template < class Facet > 
inline Facet * create_native_facet ( Facet * ) ; 

template < class Facet > 
inline Facet * create_classic_facet ( Facet * ) 
{ 
return new Facet ( 1 ) ; 
} 
#445
template < class Facet > 
class facet_maker { 
public : 
static facet_imp * maker_func ( int t , const char * name , size_t refs ) 
{ 
if ( t == 0 ) 
return create_classic_facet ( ( Facet * ) 0 ) ; 
else if ( t == 1 ) 
return create_native_facet ( ( Facet * ) 0 ) ; 
else 
return create_named_facet ( ( Facet * ) 0 , name , refs ) ; 
} 
} ; 




typedef facet_imp * facet_maker_func ( int , const char * , size_t ) ; 


} 
#238 "/opt/SUNWspro/SC5.0/include/CC/rw/rwlocale"
namespace std { 
#245
class locale { 
public : 
class facet ; 
class id ; 

friend class facet ; 
friend class id ; 

typedef int category ; 
#284
static const category collate = 0x0010 , ctype = 0x0020 , monetary = 0x0040 , numeric = 0x0080 , time = 0x0100 , messages 
#284
= 0x0200 , all = 0x03f0 , none = 0x0000 , __rw_collate_category = 0x0010 , __rw_ctype_category = 0x0020 , __rw_messages_category 
#284
= 0x0200 , __rw_Clib_LC_constants = 0x000F , __rw_num_categories = 6 , __rw_first_category = 0x0010 ; 
#296
inline locale ( ) throw ( ) ; 
#303
inline locale ( const locale & other ) throw ( ) ; 
#314
locale ( const char * name ) ; 





locale ( const locale & other , const char * name , category ) ; 
#348
inline locale ( const locale & other , facet * f ) ; 
#356
locale ( const locale & other , const locale & second , category ) ; 




~ locale ( ) 
{ 
__rwstd :: ref_counted :: remove_reference ( __imp ) ; 
} 

const locale & operator = ( const locale & other ) throw ( ) ; 
#382
string name ( ) const ; 





bool operator == ( const locale & other ) const ; 
bool operator != ( const locale & other ) const { return ! ( * this == other ) ; } 
#404
bool operator ( ) ( const string & s1 , const string & s2 ) const ; 

bool operator ( ) ( const wstring & s1 , const wstring & s2 ) const ; 





static locale global ( const locale & ) ; 
static const locale & classic ( ) ; 
#421
class facet : public __rwstd :: facet_imp { 
friend class __rwstd :: locale_imp ; 
friend class locale ; 
protected : 
facet ( size_t refs = 0 , int cat = 0 ) : 
__rwstd :: facet_imp ( refs , cat ) { } 

virtual ~ facet ( ) { } 


virtual id & __get_id ( void ) const = 0 ; 


private : 
facet ( const facet & ) ; 
void operator = ( const facet & ) ; 
} ; 
#448
class id : private __rwstd :: locale_id_imp { 
public : 
friend class locale ; 
#457
operator size_t ( ) const { return __id_value ; } 
#467
public : 
id ( ) { } 
private : 
id ( const id & ) ; 

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

private : 


friend class __rwstd :: locale_imp ; 
public : 
#487
__rwstd :: locale_imp * __imp ; 



typedef __rwstd :: facet_maker_func __facet_maker_func ; 





__rwstd :: facet_imp * __make_explicit ( const id & facet_id , bool ok_implicit , 
category facet_cat , __facet_maker_func maker ) const ; 

inline __rwstd :: facet_imp * get_facet ( size_t ) const ; 





void __install ( __rwstd :: facet_imp * f , const id & i ) const ; 

static __rwstd :: locale_imp * __the_classic_locale ; 
static __rwstd :: locale_imp * __the_native_locale ; 
static __rwstd :: locale_imp * __global ; 


inline locale ( __rwstd :: locale_imp * m ) ; 

private : 




static void init ( ) ; 
} ; 
#531
inline locale :: locale ( __rwstd :: locale_imp * m ) : __imp ( m ) { 
if ( ! __global ) init ( ) ; 
__rwstd :: ref_counted :: add_reference ( __imp ) ; 
} 


inline locale :: locale ( ) throw ( ) { 
if ( ! __global ) init ( ) ; 
__rwstd :: ref_counted :: add_reference ( __imp = __global ) ; 
} 


inline locale :: locale ( const locale & other ) throw ( ) { 
__rwstd :: ref_counted :: add_reference ( __imp = other . __imp ) ; 
} 
#573
inline locale :: locale ( const locale & other , facet * f ) : 
__imp ( new __rwstd :: locale_imp ( * other . __imp , 1 ) ) 
{ 
__install ( f , f -> __get_id ( ) ) ; 
__imp -> named_ = false ; 
} 





inline __rwstd :: facet_imp * locale :: get_facet ( size_t i ) const { 
return __imp -> get_facet ( i ) ; 
} 


} namespace __rwstd { 
#600
template < class Facet > 
inline Facet * create_named_facet ( Facet * , const char * name , size_t refs ) 
{ 
return new Facet ( refs ) ; 
} 


} 
#39 "/opt/SUNWspro/SC5.0/include/CC/rw/ctype"
namespace std { 


class ctype_base { 
public : 
enum mask { 
space = 1 << 0 , print = 1 << 1 , cntrl = 1 << 2 , upper = 1 << 3 , lower = 1 << 4 , 
alpha = 1 << 5 , digit = 1 << 6 , punct = 1 << 7 , xdigit = 1 << 8 , 
alnum = ( 1 << 5 ) | ( 1 << 6 ) , graph = 1 << 9 
} ; 
} ; 


} namespace __rwstd { 
#62
template < class charT > 
class ctype_helper { 

friend class digit_map < charT > ; 



digit_map < charT > __digit_map ; 
} ; 


} namespace std { 
#80
template < > 
class ctype_byname < char > ; 
#88
template < > 
class ctype < char > : public locale :: facet , public ctype_base , 
public __rwstd :: ctype_helper < char > 
{ 
friend class locale ; 
friend class ctype_byname < char > ; 


friend class ctype < wchar_t > ; 


public : 
typedef char char_type ; 


static const size_t table_size = 256 ; 




ctype ( const mask * tab = 0 , bool del = false , size_t refs = 0 ) ; 


bool is ( mask m , char c ) const 
{ return ( __table [ ( unsigned char ) c ] & m ) != 0 ; } 





const char * is ( const char * lo , const char * hi , mask * vec ) const ; 
const char * scan_is ( mask m , const char * low , const char * high ) const ; 
const char * scan_not ( mask m , const char * low , const char * high ) const ; 

char toupper ( char c ) const { return do_toupper ( c ) ; } 
char tolower ( char c ) const { return do_tolower ( c ) ; } 
char widen ( char c ) const { return do_widen ( c ) ; } 
char narrow ( char c , char dfault ) const { return do_narrow ( c , dfault ) ; } 

const char * toupper ( char * low , const char * high ) const 
{ return do_toupper ( low , high ) ; } 
const char * tolower ( char * low , const char * high ) const 
{ return do_tolower ( low , high ) ; } 
const char * widen ( const char * lo , const char * hi , char * to ) const 
{ return do_widen ( lo , hi , to ) ; } 
const char * narrow ( const char * lo , const char * hi , char dfault , 
char * to ) const 
{ return do_narrow ( lo , hi , dfault , to ) ; } 


static locale :: id id ; 
#145
typedef string string_type ; 
string_type widen ( const string & s ) const { return s ; } 
string narrow ( const string_type & s , char ) const { return s ; } ; 



enum { __facet_cat = locale :: __rw_ctype_category , __ok_implicit = 1 } ; 

protected : 
const mask * table ( ) const throw ( ) 
{ return __table ; } 
static const mask * classic_table ( ) throw ( ) 
{ return __classic_table ; } 


virtual ~ ctype ( ) ; 

virtual char do_toupper ( char ) const ; 
virtual const char * do_toupper ( char * low , const char * high ) const ; 
virtual char do_tolower ( char ) const ; 
virtual const char * do_tolower ( char * low , const char * high ) const ; 
virtual char do_widen ( char c ) const { return c ; } 
virtual const char * do_widen ( const char * low , const char * high , char * to ) const 
{ memcpy ( to , low , high - low ) ; return high ; } 
virtual char do_narrow ( char c , char ) const { return c ; } 
virtual const char * do_narrow ( const char * low , const char * high , 
char , char * to ) const 
{ memcpy ( to , low , high - low ) ; return high ; } 

void __initfacet ( const locale * ) ; 
private : 
static const mask __classic_table [ table_size ] ; 
const mask * __table ; 
bool __delete_it ; 
int __lower_min , __lower_max ; 
int __upper_min , __upper_max ; 
char * __to_upper_tab ; 
char * __to_lower_tab ; 
#192
locale :: id & __get_id ( void ) const { return id ; } 

} ; 





template < > 
class ctype < wchar_t > : public locale :: facet , public ctype_base , 
public __rwstd :: ctype_helper < wchar_t > 
{ 
public : 
typedef wchar_t char_type ; 

ctype ( size_t refs = 0 ) ; 

bool is ( mask m , wchar_t c ) const 
{ return do_is ( m , c ) ; } 

const wchar_t * is ( const wchar_t * lo , const wchar_t * hi , mask * vec ) const 
{ return do_is ( lo , hi , vec ) ; } 

const wchar_t * scan_is ( mask m , const wchar_t * lo , const wchar_t * hi ) const 
{ return do_scan_is ( m , lo , hi ) ; } 

const wchar_t * scan_not ( mask m , const wchar_t * lo , const wchar_t * hi ) const 
{ return do_scan_not ( m , lo , hi ) ; } 

wchar_t toupper ( wchar_t c ) const 
{ return do_toupper ( c ) ; } 

const wchar_t * toupper ( wchar_t * lo , const wchar_t * hi ) const 
{ return do_toupper ( lo , hi ) ; } 

wchar_t tolower ( wchar_t c ) const 
{ return do_tolower ( c ) ; } 

const wchar_t * tolower ( wchar_t * lo , const wchar_t * hi ) const 
{ return do_tolower ( lo , hi ) ; } 

wchar_t widen ( char c ) const 
{ return do_widen ( c ) ; } 

const char * widen ( const char * lo , const char * hi , wchar_t * to ) const 
{ return do_widen ( lo , hi , to ) ; } 

char narrow ( wchar_t c , char dfault ) const 
{ return do_narrow ( c , dfault ) ; } 

const wchar_t * narrow ( const wchar_t * lo , const wchar_t * hi , char dfault , 
char * to ) const 
{ return do_narrow ( lo , hi , dfault , to ) ; } 


static locale :: id id ; 
#254
typedef wstring string_type ; 
string_type widen ( const string & ) const ; 
string narrow ( const string_type & , char ) const ; 



enum { __facet_cat = locale :: __rw_ctype_category , __ok_implicit = 1 } ; 

protected : 
virtual ~ ctype ( ) { } 

virtual bool do_is ( mask , wchar_t ) const ; 
virtual const wchar_t * do_is ( const wchar_t * , const wchar_t * , mask * ) const ; 
virtual const wchar_t * do_scan_is ( mask , const wchar_t * , const wchar_t * ) const ; 
virtual const wchar_t * do_scan_not ( mask , const wchar_t * , const wchar_t * ) const ; 
virtual wchar_t do_toupper ( wchar_t ) const ; 
virtual const wchar_t * do_toupper ( wchar_t * , const wchar_t * ) const ; 
virtual wchar_t do_tolower ( wchar_t ) const ; 
virtual const wchar_t * do_tolower ( wchar_t * , const wchar_t * ) const ; 
virtual wchar_t do_widen ( char ) const ; 
virtual const char * do_widen ( const char * , const char * , wchar_t * ) const ; 
virtual char do_narrow ( wchar_t , char dfault ) const ; 
virtual const wchar_t * do_narrow ( const wchar_t * , const wchar_t * , 
char dfault , char * dest ) const ; 
private : 
static mask mask_of ( wchar_t ) ; 


locale :: id & __get_id ( void ) const { return id ; } 

} ; 



template < class charT > 
class ctype : public locale :: facet , public ctype_base , 
public __rwstd :: ctype_helper < charT > 
{ 
public : 
typedef charT char_type ; 

ctype ( size_t refs = 0 ) ; 

bool is ( mask m , charT c ) const 
{ return do_is ( m , c ) ; } 
const charT * is ( const charT * low , const charT * high , mask * vec ) const 
{ return do_is ( low , high , vec ) ; } 
const charT * scan_is ( mask m , const charT * low , const charT * high ) const 
{ return do_scan_is ( m , low , high ) ; } 
const charT * scan_not ( mask m , const charT * low , const charT * high ) const 
{ return do_scan_not ( m , low , high ) ; } 

charT toupper ( charT c ) const 
{ return do_toupper ( c ) ; } 
const charT * toupper ( charT * low , const charT * high ) const 
{ return do_toupper ( low , high ) ; } 
charT tolower ( charT c ) const 
{ return do_tolower ( c ) ; } 
const charT * tolower ( charT * low , const charT * high ) const 
{ return do_tolower ( low , high ) ; } 

charT widen ( char c ) const { return do_widen ( c ) ; } 
const char * widen ( const char * lo , const char * hi , charT * to ) const 
{ return do_widen ( lo , hi , to ) ; } 
char narrow ( charT c , char dfault ) const { return do_narrow ( c , dfault ) ; } 
const charT * narrow ( const charT * lo , const charT * hi , 
char dfault , char * to ) const 
{ return do_narrow ( lo , hi , dfault , to ) ; } 

static locale :: id id ; 



typedef basic_string < charT , char_traits < charT > , allocator < charT > > string_type ; 
string_type widen ( const string & ) const ; 
string narrow ( const string_type & , char ) const ; 



enum { __facet_cat = locale :: __rw_ctype_category , __ok_implicit = 1 } ; 

protected : 
inline virtual ~ ctype ( ) { } 

virtual bool do_is ( mask m , charT c ) const 
{ return false ; } 
virtual const charT * do_is ( 
const charT * low , const charT * high , mask * vec ) const 
{ return high ; } 
virtual const charT * do_scan_is ( 
mask m , const charT * low , const charT * high ) const 
{ return high ; } 
virtual const charT * do_scan_not ( 
mask m , const charT * low , const charT * high ) const 
{ return high ; } 
virtual charT do_toupper ( charT c ) const 
{ return c ; } 
virtual const charT * do_toupper ( charT * low , const charT * high ) const 
{ return high ; } 
virtual charT do_tolower ( charT c ) const 
{ return c ; } 
virtual const charT * do_tolower ( charT * low , const charT * high ) const 
{ return high ; } 

virtual charT do_widen ( char c ) const 
{ return charT ( c ) ; } 
virtual const char * do_widen ( const char * lo , 
const char * hi , charT * dest ) const 
{ 
while ( lo < hi ) 
* dest ++ = charT ( * lo ++ ) ; 
return hi ; 
} 
virtual char do_narrow ( charT c , char dfault ) const 
{ return dfault ; } 
virtual const charT * do_narrow ( const charT * lo , const charT * hi , 
char dfault , char * dest ) const 
{ return hi ; } 

private : 

locale :: id & __get_id ( void ) const { return id ; } 


} ; 
#389
template < > 
class ctype_byname < char > : public ctype < char > { 
public : 
ctype_byname ( const char * , size_t refs = 0 ) ; 

protected : 
virtual ~ ctype_byname ( ) ; 

private : 

static const mask * get_mask_table ( const char * ) ; 
} ; 
#408
template < > 
class ctype_byname < wchar_t > : public ctype < wchar_t > { 
public : 
ctype_byname ( const char * , size_t refs = 0 ) ; 

protected : 
virtual ~ ctype_byname ( ) ; 
#431
} ; 
#439
template < class charT > 
class ctype_byname : public ctype < charT > { 
public : 
ctype_byname ( const char * , size_t refs = 0 ) : 
ctype < charT > ( refs ) { } 

protected : 
virtual ~ ctype_byname ( ) { } 
#463
} ; 


} namespace __rwstd { 


inline const digit_map < char > & 
digit_map < char > :: get_digit_map ( const std :: ctype < char > & ct ) 
{ 
return ct . __digit_map ; 
} 


template < > 
inline std :: ctype < char > * create_named_facet < std :: ctype < char > > 



( std :: ctype < char > * , const char * name , size_t refs ) 
{ return new std :: ctype_byname < char > ( name , refs ) ; } 


template < > 
inline std :: ctype < char > * create_classic_facet < std :: ctype < char > > 



( std :: ctype < char > * ) 
{ return new std :: ctype < char > ( 0 , false , 1 ) ; } 



} 
#73 "/opt/SUNWspro/SC5.0/include/CC/rw/iosbase"
namespace std { 


typedef long SZ_T ; 
typedef SZ_T streamsize ; 

class __Wide_Init 
{ 
static int __initcnt ; 
public : 
static int getinit_cnt_ ( ) { return __initcnt ; } 
__Wide_Init ( ) ; 
~ __Wide_Init ( ) ; 
} ; 





class ios_base 
{ 
public : 



class failure : public exception 
{ 
public : 
failure ( const string & msg ) ; 
virtual ~ failure ( ) throw ( ) ; 
virtual const char * what ( ) const throw ( ) ; 

private : 
string __str ; 
} ; 


typedef int fmtflags ; 

enum fmt_flags { 
boolalpha = 0x0001 , 
dec = 0x0002 , 
fixed = 0x0004 , 
hex = 0x0008 , 
internal = 0x0010 , 
left = 0x0020 , 
oct = 0x0040 , 
right = 0x0080 , 
scientific = 0x0100 , 
showbase = 0x0200 , 
showpoint = 0x0400 , 
showpos = 0x0800 , 
skipws = 0x1000 , 
unitbuf = 0x2000 , 
uppercase = 0x4000 , 
adjustfield = left | right | internal , 
basefield = dec | oct | hex , 
floatfield = scientific | fixed 
} ; 

typedef int iostate ; 

enum io_state { 
goodbit = 0x00 , 
badbit = 0x01 , 
eofbit = 0x02 , 
failbit = 0x04 
} ; 

typedef int openmode ; 

enum open_mode { 
app = 0x01 , 
binary = 0x02 , 
in = 0x04 , 
out = 0x08 , 
trunc = 0x10 , 



ate = 0x20 , 
nocreate = 0x40 , 
noreplace = 0x80 

} ; 

typedef int seekdir ; 

enum seek_dir { 
beg = 0x0 , 
cur = 0x1 , 
end = 0x2 
} ; 

enum EmptyCtor { emptyctor } ; 

class Init { 
static int __initcnt ; 
public : 
static int getinit_cnt_ ( ) { return __initcnt ; } 
Init ( ) ; 
~ Init ( ) ; 
} ; 

inline fmtflags flags ( ) const ; 
inline fmtflags flags ( fmtflags fmtfl ) ; 
inline fmtflags setf ( fmtflags fmtfl ) ; 
inline fmtflags setf ( fmtflags fmtfl , fmtflags mask ) ; 
inline void unsetf ( fmtflags mask ) ; 

inline streamsize precision ( ) const ; 
inline streamsize precision ( streamsize prec ) ; 
inline streamsize width ( ) const ; 
inline streamsize width ( streamsize wide ) ; 

locale imbue ( const locale & loc ) ; 
locale getloc ( ) const 
{ return __loc ; } 

static int xalloc ( ) ; 
long & iword ( int index ) ; 
void * & pword ( int index ) ; 

enum event { 
erase_event = 0x0001 , 
imbue_event = 0x0002 , 
copyfmt_event = 0x0004 
} ; 

typedef void ( * event_callback ) ( event , ios_base & , int index ) ; 
void register_callback ( event_callback fn , int index ) ; 

ios_base & copyfmt ( const ios_base & rhs ) ; 
ios_base & _RW_UNSAFE_copyfmt ( const ios_base & rhs ) ; 

bool is_synch ( ) 
{ return __sync_with_stdio ; } 

static bool sync_with_stdio ( bool sync = true ) 
{ 
bool tmp = __sync_with_stdio ; 
__sync_with_stdio = sync ; 
return tmp ; 
} 

virtual ~ ios_base ( ) ; 

protected : 

ios_base ( ) ; 
ios_base ( int ) { } 

fmtflags __fmtfl ; 
streamsize __prec ; 
streamsize __wide ; 


_RWSTDMutex __stream_mutex ; 


private : 

void usersize ( int ) ; 
locale __loc ; 

union ios_user_union { 
long __lword ; 
void * __pword ; 
} ; 

struct register_call { 
int __index ; 
event_callback __fn ; 
} ; 

static int __index ; 
int __index_cp ; 
int __index_callback ; 
union ios_user_union * __userwords ; 
struct register_call * __registered_call ; 
static bool __sync_with_stdio ; 
} ; 
#264
inline ios_base :: fmtflags 
ios_base :: flags ( ) const 
{ 
return __fmtfl ; 
} 





inline ios_base :: fmtflags 
ios_base :: flags ( ios_base :: fmtflags flgs ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

ios_base :: fmtflags f = __fmtfl ; 
__fmtfl = flgs ; 
return f ; 
} 





inline ios_base :: fmtflags 
ios_base :: setf ( ios_base :: fmtflags flgs ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

ios_base :: fmtflags f = __fmtfl ; 
__fmtfl |= flgs ; 
return f ; 
} 





inline ios_base :: fmtflags 
ios_base :: setf ( ios_base :: fmtflags flgs , ios_base :: fmtflags mask ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

ios_base :: fmtflags old = __fmtfl ; 
__fmtfl &= ~ mask ; 
__fmtfl |= ( flgs & mask ) ; 
return old ; 
} 





inline void 
ios_base :: unsetf ( ios_base :: fmtflags fg ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

__fmtfl &= ~ fg ; 
} 





inline streamsize 
ios_base :: precision ( ) const 
{ 
return __prec ; 
} 
#344
inline streamsize 
ios_base :: precision ( streamsize p ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

streamsize temp = __prec ; 
__prec = p ; 
return temp ; 
} 





inline streamsize 
ios_base :: width ( ) const 
{ 
return __wide ; 
} 





inline streamsize 
ios_base :: width ( streamsize w ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

streamsize i = __wide ; 
__wide = w ; 
return i ; 
} 





inline ios_base & unitbuf ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: unitbuf ) ; 
return strm ; 
} 





inline ios_base & nounitbuf ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: unitbuf ) ; 
return strm ; 
} 
#405
inline ios_base & boolalpha ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: boolalpha ) ; 
return strm ; 
} 





inline ios_base & noboolalpha ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: boolalpha ) ; 
return strm ; 
} 





inline ios_base & showbase ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: showbase ) ; 
return strm ; 
} 





inline ios_base & noshowbase ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: showbase ) ; 
return strm ; 
} 





inline ios_base & showpoint ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: showpoint ) ; 
return strm ; 
} 





inline ios_base & noshowpoint ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: showpoint ) ; 
return strm ; 
} 





inline ios_base & showpos ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: showpos ) ; 
return strm ; 
} 





inline ios_base & noshowpos ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: showpos ) ; 
return strm ; 
} 





inline ios_base & skipws ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: skipws ) ; 
return strm ; 
} 





inline ios_base & noskipws ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: skipws ) ; 
return strm ; 
} 
#506
inline ios_base & uppercase ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: uppercase ) ; 
return strm ; 
} 





inline ios_base & nouppercase ( ios_base & strm ) 
{ 
strm . unsetf ( ios_base :: uppercase ) ; 
return strm ; 
} 

inline ios_base & internal ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: internal , ios_base :: adjustfield ) ; 
return strm ; 
} 





inline ios_base & left ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: left , ios_base :: adjustfield ) ; 
return strm ; 
} 





inline ios_base & right ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: right , ios_base :: adjustfield ) ; 
return strm ; 
} 





inline ios_base & dec ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: dec , ios_base :: basefield ) ; 
return strm ; 
} 





inline ios_base & hex ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: hex , ios_base :: basefield ) ; 
return strm ; 
} 





inline ios_base & oct ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: oct , ios_base :: basefield ) ; 
return strm ; 
} 





inline ios_base & fixed ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: fixed , ios_base :: floatfield ) ; 
return strm ; 
} 





inline ios_base & scientific ( ios_base & strm ) 
{ 
strm . setf ( ios_base :: scientific , ios_base :: floatfield ) ; 
return strm ; 
} 
#605
} 
#12 "/opt/SUNWspro/SC5.0/include/CC/std/math.h"
#pragma ident "@(#)math.h	1.6  02/01/99 C++5.0" 
#21
typedef union _h_val { 



unsigned long _i [ sizeof ( double ) / sizeof ( unsigned long ) ] ; 

double _d ; 
} _h_val ; 
extern "C" const _h_val __huge_val ; 
#37
namespace std { 

extern "C" { 
double acos ( double ) ; 
double asin ( double ) ; 
double atan ( double ) ; 
double atan2 ( double , double ) ; 
double cos ( double ) ; 
double sin ( double ) ; 
double tan ( double ) ; 

double cosh ( double ) ; 
double sinh ( double ) ; 
double tanh ( double ) ; 

double exp ( double ) ; 
double frexp ( double , int * ) ; 
double ldexp ( double , int ) ; 
double log ( double ) ; 
double log10 ( double ) ; 
double modf ( double , double * ) ; 

double pow ( double , double ) ; 
double sqrt ( double ) ; 

double ceil ( double ) ; 
double fabs ( double ) ; 
double floor ( double ) ; 
double fmod ( double , double ) ; 
} 

extern double abs ( double ) ; 
extern double pow ( double , int ) ; 

} 
#81
using std :: acos ; 
using std :: asin ; 
using std :: atan2 ; 
using std :: atan ; 
using std :: ceil ; 
using std :: cos ; 
using std :: cosh ; 
using std :: exp ; 
using std :: fabs ; 
using std :: floor ; 
using std :: fmod ; 
using std :: frexp ; 
using std :: ldexp ; 
using std :: log10 ; 
using std :: log ; 
using std :: modf ; 
using std :: pow ; 
using std :: sin ; 
using std :: sinh ; 
using std :: sqrt ; 
using std :: tan ; 
using std :: tanh ; 
#114
extern "C" { 
#135
extern int signgam ; 
#143
enum version { libm_ieee = - 1 , c_issue_4 , ansi_1 , strict_ansi } ; 
extern const enum version _lib_version ; 

struct math_exception { 
int type ; 
char * name ; 
double arg1 ; 
double arg2 ; 
double retval ; 
} ; 
#186
extern double erf ( double ) ; 
extern double erfc ( double ) ; 
extern double gamma ( double ) ; 
extern double hypot ( double , double ) ; 
extern int isnan ( double ) ; 
extern double j0 ( double ) ; 
extern double j1 ( double ) ; 
extern double jn ( int , double ) ; 
extern double lgamma ( double ) ; 
extern double y0 ( double ) ; 
extern double y1 ( double ) ; 
extern double yn ( int , double ) ; 
#205
extern double acosh ( double ) ; 
extern double asinh ( double ) ; 
extern double atanh ( double ) ; 
extern double cbrt ( double ) ; 
extern double logb ( double ) ; 
extern double nextafter ( double , double ) ; 
extern double remainder ( double , double ) ; 
extern double scalb ( double , double ) ; 




extern double expm1 ( double ) ; 
extern int ilogb ( double ) ; 
extern double log1p ( double ) ; 
extern double rint ( double ) ; 
#227
extern int matherr ( struct math_exception * ) ; 




extern double significand ( double ) ; 




extern double copysign ( double , double ) ; 
extern double scalbn ( double , int ) ; 
#252
extern float modff ( float , float * ) ; 
#12 "/usr/include/floatingpoint.h"
extern "C" { 


#pragma ident "@(#)floatingpoint.h	2.4 94/06/09" 
#8 "/usr/include/sys/ieeefp.h"
#pragma ident "@(#)ieeefp.h	2.7 94/11/09" 


extern "C" { 
#18
enum fp_direction_type { 
fp_nearest = 0 , 
fp_tozero = 1 , 
fp_positive = 2 , 
fp_negative = 3 
} ; 

enum fp_precision_type { 
fp_extended = 0 , 
fp_single = 1 , 
fp_double = 2 , 
fp_precision_3 = 3 
} ; 

enum fp_exception_type { 
fp_inexact = 0 , 
fp_division = 1 , 
fp_underflow = 2 , 
fp_overflow = 3 , 
fp_invalid = 4 
} ; 

enum fp_trap_enable_type { 
fp_trap_inexact = 0 , 
fp_trap_division = 1 , 
fp_trap_underflow = 2 , 
fp_trap_overflow = 3 , 
fp_trap_invalid = 4 
} ; 
#124
enum fp_class_type { 
fp_zero = 0 , 
fp_subnormal = 1 , 
fp_normal = 2 , 
fp_infinity = 3 , 
fp_quiet = 4 , 
fp_signaling = 5 
} ; 


} 
#45 "/usr/include/floatingpoint.h"
typedef int sigfpe_code_type ; 

typedef void ( * sigfpe_handler_type ) ( ) ; 





extern sigfpe_handler_type sigfpe ( sigfpe_code_type , sigfpe_handler_type ) ; 




typedef float single ; 



typedef unsigned extended [ 3 ] ; 


typedef long double quadruple ; 

typedef unsigned fp_exception_field_type ; 
#77
typedef char decimal_string [ 512 ] ; 


typedef struct { 
enum fp_class_type fpclass ; 
int sign ; 
int exponent ; 
decimal_string ds ; 


int more ; 


int ndigits ; 


} decimal_record ; 

enum decimal_form { 
fixed_form , 


floating_form 

} ; 

typedef struct { 
enum fp_direction_type rd ; 

enum decimal_form df ; 

int ndigits ; 
} decimal_mode ; 

enum decimal_string_form { 
invalid_form , 
whitespace_form , 
fixed_int_form , 
fixed_intdot_form , 
fixed_dotfrac_form , 
fixed_intdotfrac_form , 
floating_int_form , 
floating_intdot_form , 
floating_dotfrac_form , 
floating_intdotfrac_form , 
inf_form , 
infinity_form , 
nan_form , 
nanstring_form 
} ; 

extern void single_to_decimal 
( single * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 
extern void double_to_decimal 
( double * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 
extern void extended_to_decimal 
( extended * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 
extern void quadruple_to_decimal 
( quadruple * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 

extern void decimal_to_single 
( single * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 
extern void decimal_to_double 
( double * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 
extern void decimal_to_extended 
( extended * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 
extern void decimal_to_quadruple 
( quadruple * , decimal_mode * , decimal_record * , fp_exception_field_type * ) ; 

extern void string_to_decimal 
( char * * , int , int , decimal_record * , enum decimal_string_form * , char * * ) ; 
extern void func_to_decimal 

( char * * , int , int , decimal_record * , enum decimal_string_form * , char * * , int ( * ) ( void ) , int * , int ( * 
#150
) ( int ) ) ; 
extern void file_to_decimal 

( char * * , int , int , decimal_record * , enum decimal_string_form * , char * * , FILE * , int * ) ; 

extern char * seconvert ( single * , int , int * , int * , char * ) ; 
extern char * sfconvert ( single * , int , int * , int * , char * ) ; 
extern char * sgconvert ( single * , int , int , char * ) ; 
extern char * econvert ( double , int , int * , int * , char * ) ; 
extern char * fconvert ( double , int , int * , int * , char * ) ; 
extern char * gconvert ( double , int , int , char * ) ; 
extern char * qeconvert ( quadruple * , int , int * , int * , char * ) ; 
extern char * qfconvert ( quadruple * , int , int * , int * , char * ) ; 
extern char * qgconvert ( quadruple * , int , int , char * ) ; 

extern char * ecvt ( double , int , int * , int * ) ; 
extern char * fcvt ( double , int , int * , int * ) ; 
extern char * gcvt ( double , int , char * ) ; 





extern double atof ( const char * ) ; 
extern double strtod ( const char * , char * * ) ; 


} 
#258 "/opt/SUNWspro/SC5.0/include/CC/std/math.h"
} 
#13 "/opt/SUNWspro/SC5.0/include/CC/std/float.h"
#pragma ident "@(#)float.h	1.5  02/01/99 C++5.0" 





extern "C" { 


extern int __flt_rounds ( void ) ; 
#30
} 
#88
namespace std { 
} 
#61 "/opt/SUNWspro/SC5.0/include/CC/./limits"
namespace std { 
#73
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 
} ; 
#131
template < class T > 
class numeric_limits ; 





template < > 
class numeric_limits < float > 
{ 
public : 

static const bool is_specialized = true ; 

static inline float min ( ) throw ( ) { return 1.175494351E-38F ; } 
static inline float max ( ) throw ( ) { return 3.402823466E+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 inline float epsilon ( ) throw ( ) { return 1.192092896E-07F ; } 
static float round_error ( ) throw ( ) ; 

static const int min_exponent = ( - 125 ) ; 
static const int min_exponent10 = ( - 37 ) ; 
static const int max_exponent = ( + 128 ) ; 
static const int max_exponent10 = ( + 38 ) ; 

static const bool has_infinity = false ; 
static const bool has_quiet_NaN = false ; 
static const bool has_signaling_NaN = false ; 
static const float_denorm_style has_denorm = denorm_indeterminate ; 
static const bool has_denorm_loss = false ; 

static float infinity ( ) throw ( ) ; 
static float quiet_NaN ( ) throw ( ) ; 
static float signaling_NaN ( ) throw ( ) ; 
static float denorm_min ( ) throw ( ) ; 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = false ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 


static const float_round_style round_style ; 



} ; 





template < > 
class numeric_limits < double > 
{ 
public : 

static const bool is_specialized = true ; 

static inline double min ( ) throw ( ) { return 2.2250738585072014E-308 ; } 
static inline 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 inline double epsilon ( ) throw ( ) { return 2.2204460492503131E-16 ; } 
static double round_error ( ) throw ( ) ; 

static const int min_exponent = ( - 1021 ) ; 
static const int min_exponent10 = ( - 307 ) ; 
static const int max_exponent = ( + 1024 ) ; 
static const int max_exponent10 = ( + 308 ) ; 

static const bool has_infinity = false ; 
static const bool has_quiet_NaN = false ; 
static const bool has_signaling_NaN = false ; 
static const float_denorm_style has_denorm = denorm_indeterminate ; 
static const bool has_denorm_loss = false ; 

static double infinity ( ) throw ( ) ; 
static double quiet_NaN ( ) throw ( ) ; 
static double signaling_NaN ( ) throw ( ) ; 
static double denorm_min ( ) throw ( ) ; 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = false ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 


static const float_round_style round_style ; 



} ; 
#252
template < > 
class numeric_limits < long double > 
{ 
public : 

static const bool is_specialized = true ; 

static inline long double min ( ) throw ( ) { return 3.362103143112093506262677817321752603E-4932L ; } 
static inline long double max ( ) throw ( ) { return 1.189731495357231765085759326628007016E+4932L ; } 

static const int digits = 113 ; 
static const int digits10 = 33 ; 

static const bool is_signed = true ; 
static const bool is_integer = false ; 
static const bool is_exact = false ; 

static const int radix = 2 ; 

static inline long double epsilon ( ) throw ( ) { return 1.925929944387235853055977942584927319E-34L ; } 
static long double round_error ( ) throw ( ) ; 

static const int min_exponent = ( - 16381 ) ; 
static const int min_exponent10 = ( - 4931 ) ; 
static const int max_exponent = ( + 16384 ) ; 
static const int max_exponent10 = ( + 4932 ) ; 

static const bool has_infinity = false ; 
static const bool has_quiet_NaN = false ; 
static const bool has_signaling_NaN = false ; 
static const float_denorm_style has_denorm = denorm_indeterminate ; 
static const bool has_denorm_loss = false ; 

static long double infinity ( ) throw ( ) ; 
static long double quiet_NaN ( ) throw ( ) ; 
static long double signaling_NaN ( ) throw ( ) ; 
static long double denorm_min ( ) throw ( ) ; 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = false ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 


static const float_round_style round_style ; 



} ; 
#309
template < > 
class numeric_limits < int > 
{ 
public : 

static const bool is_specialized = true ; 

static inline int min ( ) throw ( ) { return ( - 2147483647 - 1 ) ; } 
static inline int max ( ) throw ( ) { return 2147483647 ; } 

static const int digits = 8 * sizeof ( int ) - 1 ; 

static const int digits10 ; 

static const bool is_signed = true ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = 2 ; 

static inline int epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline int infinity ( ) throw ( ) { return 0 ; } 
static inline int quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline int signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline int denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = false ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 



template < > 
class numeric_limits < wchar_t > 
{ 
public : 

static const bool is_specialized = true ; 

static wchar_t min ( ) throw ( ) ; 
static wchar_t max ( ) throw ( ) ; 

static const bool is_signed = true ; 

static const int digits = is_signed ? 8 * sizeof ( wchar_t ) - 1 : 8 * sizeof ( wchar_t ) ; 

static const int digits10 ; 

static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline wchar_t epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline wchar_t infinity ( ) throw ( ) { return 0 ; } 
static inline wchar_t quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline wchar_t signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline wchar_t denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = is_signed ? numeric_limits < int > :: is_modulo : true ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 
#421
template < > 
class numeric_limits < short > 
{ 
public : 

static const bool is_specialized = true ; 

static inline short min ( ) throw ( ) { return ( - 32768 ) ; } 
static inline short max ( ) throw ( ) { return 32767 ; } 

static const int digits = 8 * sizeof ( short ) - 1 ; 

static const int digits10 ; 

static const bool is_signed = true ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline short epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline short infinity ( ) throw ( ) { return 0 ; } 
static inline short quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline short signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline short denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = numeric_limits < int > :: is_modulo ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < unsigned short > 
{ 
public : 

static const bool is_specialized = true ; 

static inline unsigned short min ( ) throw ( ) { return 0 ; } 
static inline unsigned short max ( ) throw ( ) { return 65535 ; } 

static const int digits = 8 * sizeof ( unsigned short ) ; 

static const int digits10 ; 

static const bool is_signed = false ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline unsigned short epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline unsigned short infinity ( ) throw ( ) { return 0 ; } 
static inline unsigned short quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned short signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned short denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = true ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < unsigned int > 
{ 
public : 

static const bool is_specialized = true ; 

static inline unsigned int min ( ) throw ( ) { return 0 ; } 
static inline unsigned int max ( ) throw ( ) { return 4294967295U ; } 

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

static const int digits10 ; 

static const bool is_signed = false ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline unsigned int epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline unsigned int infinity ( ) throw ( ) { return 0 ; } 
static inline unsigned int quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned int signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned int denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = true ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < long > 
{ 
public : 

static const bool is_specialized = true ; 

static inline long min ( ) throw ( ) { return ( - 2147483647L - 1L ) ; } 
static inline long max ( ) throw ( ) { return 2147483647L ; } 

static const int digits = 8 * sizeof ( long ) - 1 ; 

static const int digits10 ; 

static const bool is_signed = true ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline long epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline long infinity ( ) throw ( ) { return 0 ; } 
static inline long quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline long signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline long denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = numeric_limits < int > :: is_modulo ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < unsigned long > 
{ 
public : 

static const bool is_specialized = true ; 

static inline unsigned long min ( ) throw ( ) { return 0 ; } 
static inline unsigned long max ( ) throw ( ) { return 4294967295UL ; } 

static const int digits = 8 * sizeof ( unsigned long ) ; 

static const int digits10 ; 

static const bool is_signed = false ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline unsigned long epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline unsigned long infinity ( ) throw ( ) { return 0 ; } 
static inline unsigned long quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned long signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned long denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = true ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < char > 
{ 
public : 

static const bool is_specialized = true ; 

static inline char min ( ) throw ( ) { return ( - 128 ) ; } 
static inline char max ( ) throw ( ) { return 127 ; } 

static const bool is_signed = 127 == 127 ? true : false ; 

static const int digits = is_signed ? 8 * sizeof ( char ) - 1 : 8 * sizeof ( char ) ; 

static const int digits10 ; 

static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline char epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline char infinity ( ) throw ( ) { return 0 ; } 
static inline char quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline char signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline char denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = is_signed ? numeric_limits < int > :: is_modulo : true ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < unsigned char > 
{ 
public : 

static const bool is_specialized = true ; 

static inline unsigned char min ( ) throw ( ) { return 0 ; } 
static inline unsigned char max ( ) throw ( ) { return 255 ; } 

static const int digits = 8 * sizeof ( unsigned char ) ; 

static const int digits10 ; 

static const bool is_signed = false ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline unsigned char epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline unsigned char infinity ( ) throw ( ) { return 0 ; } 
static inline unsigned char quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned char signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline unsigned char denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = true ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 





template < > 
class numeric_limits < signed char > 
{ 
public : 

static const bool is_specialized = true ; 

static inline signed char min ( ) throw ( ) { return ( - 128 ) ; } 
static inline signed char max ( ) throw ( ) { return 127 ; } 

static const int digits = 8 * sizeof ( signed char ) - 1 ; 

static const int digits10 ; 

static const bool is_signed = true ; 
static const bool is_integer = true ; 
static const bool is_exact = true ; 

static const int radix = numeric_limits < int > :: radix ; 

static inline signed char epsilon ( ) throw ( ) { return 0 ; } 
static inline 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 inline signed char infinity ( ) throw ( ) { return 0 ; } 
static inline signed char quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline signed char signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline signed char denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = numeric_limits < int > :: is_modulo ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 
#848
template < > 
class numeric_limits < bool > 
{ 
public : 

static const bool is_specialized = true ; 

static inline bool min ( ) throw ( ) { return false ; } 
static inline 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 = numeric_limits < int > :: radix ; 

static inline bool epsilon ( ) throw ( ) { return 0 ; } 
static inline bool 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 inline int infinity ( ) throw ( ) { return 0 ; } 
static inline int quiet_NaN ( ) throw ( ) { return 0 ; } 
static inline int signaling_NaN ( ) throw ( ) { return 0 ; } 
static inline int denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 = false ; 
static const bool is_bounded = true ; 
static const bool is_modulo = false ; 

static const bool traps = false ; 
static const bool tinyness_before = false ; 

static const float_round_style round_style = round_toward_zero ; 
} ; 




template < class T > 
class numeric_limits 
{ 
public : 

static const bool is_specialized ; 

static inline T min ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 
static inline T max ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 

static const int digits ; 
static const int digits10 ; 

static const bool is_signed ; 
static const bool is_integer ; 
static const bool is_exact ; 

static const int radix ; 
static inline T epsilon ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 
static inline T round_error ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 

static const int min_exponent ; 
static const int min_exponent10 ; 
static const int max_exponent ; 
static const int max_exponent10 ; 

static const bool has_infinity ; 
static const bool has_quiet_NaN ; 
static const bool has_signaling_NaN ; 
static const float_denorm_style has_denorm ; 
static const bool has_denorm_loss ; 

static inline T infinity ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 
static inline T quiet_NaN ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 
static inline T signaling_NaN ( ) throw ( ) { return static_cast < T > ( 0 ) ; } 

static inline T denorm_min ( ) throw ( ) { return min ( ) ; } 

static const bool is_iec559 ; 
static const bool is_bounded ; 
static const bool is_modulo ; 

static const bool traps ; 
static const bool tinyness_before ; 

static const float_round_style round_style ; 
} ; 


template < class T > 
const bool numeric_limits < T > :: is_specialized = false ; 

template < class T > 
const int numeric_limits < T > :: digits = 0 ; 

template < class T > 
const int numeric_limits < T > :: digits10 = 0 ; 

template < class T > 
const bool numeric_limits < T > :: is_signed = false ; 

template < class T > 
const bool numeric_limits < T > :: is_integer = false ; 

template < class T > 
const bool numeric_limits < T > :: is_exact = false ; 

template < class T > 
const int numeric_limits < T > :: radix = 0 ; 

template < class T > 
const int numeric_limits < T > :: min_exponent10 = 0 ; 

template < class T > 
const int numeric_limits < T > :: max_exponent10 = 0 ; 

template < class T > 
const int numeric_limits < T > :: min_exponent = 0 ; 

template < class T > 
const int numeric_limits < T > :: max_exponent = 0 ; 

template < class T > 
const bool numeric_limits < T > :: has_infinity = false ; 

template < class T > 
const bool numeric_limits < T > :: has_quiet_NaN = false ; 

template < class T > 
const bool numeric_limits < T > :: has_signaling_NaN = false ; 

template < class T > 
const bool numeric_limits < T > :: is_iec559 = false ; 

template < class T > 
const bool numeric_limits < T > :: is_bounded = false ; 

template < class T > 
const bool numeric_limits < T > :: is_modulo = false ; 

template < class T > 
const float_denorm_style numeric_limits < T > :: has_denorm = denorm_absent ; 

template < class T > 
const bool numeric_limits < T > :: has_denorm_loss = false ; 

template < class T > 
const bool numeric_limits < T > :: traps = false ; 

template < class T > 
const bool numeric_limits < T > :: tinyness_before = false ; 

template < class T > 
const float_round_style numeric_limits < T > :: round_style = round_toward_zero ; 
#1020
} 
#46 "/opt/SUNWspro/SC5.0/include/CC/rw/numeral"
namespace __rwstd { 
#55
template < class charT > 
class numpunct_init { 
public : 
bool del_ ; 
charT dp_ , ts_ ; 
const char * gr_ ; 
const charT * tn_ , * fn_ ; 
} ; 
#71
class numpunct_base { 
public : 
static numpunct_init < char > * get_named_init_ ( const char * ) ; 
} ; 
#83
template < class charT > 
class numpunct_data : 
public numpunct_base , 
public punct_data < charT > 
{ 

friend class std :: numpunct < charT > ; 



friend class keyword_cracker < charT > ; 

typedef std :: basic_string < charT , std :: char_traits < charT > , std :: allocator < charT > > string_type ; 

string_type tn_ , fn_ ; 

keyword_def < charT > tf_defs_ [ 2 ] ; 
keyword_map < charT > tf_map_ ; 

protected : 
inline numpunct_data ( const numpunct_init < charT > * ) ; 
numpunct_init < charT > * get_init_by_name_ ( const char * ) ; 
void __initfacetbase ( const locale * ) ; 
} ; 

template < class charT > 
inline numpunct_data < charT > :: numpunct_data 
( const numpunct_init < charT > * init ) 
{ 
if ( ! init ) { 
this -> dp_ = charT ( '.' ) ; 
this -> ts_ = charT ( ',' ) ; 
} else { 
this -> dp_ = init -> dp_ ; 
this -> ts_ = init -> ts_ ; 
this -> gr_ = init -> gr_ ; 
tn_ = init -> tn_ ; 
fn_ = init -> fn_ ; 

if ( init -> del_ ) 
delete [ ] ( char * ) init ; 
} 
} 

template < class charT > 
numpunct_init < charT > * 
fixup_numpunct_init 
( numpunct_init < char > * , charT * ) ; 


template < > 
inline numpunct_init < char > * 
fixup_numpunct_init < char > ( numpunct_init < char > * init , char * ) 




{ return init ; } 
#151
template < class charT > 
class numpunct_impl : 
public numpunct_data < charT > 
{ 
protected : 
numpunct_impl ( const numpunct_init < charT > * init ) 
: numpunct_data < charT > ( init ) { } 
public : 
static const numpunct_init < charT > * get_ivals_ ( ) 
{ return 0 ; } 
} ; 

template < > 
class numpunct_impl < char > : 
public numpunct_data < char > 
{ 

static numpunct_init < char > ivals_ ; 




protected : 
numpunct_impl 
( const numpunct_init < char > * init ) : 
numpunct_data < char > ( init ) { } 
public : 
static const numpunct_init < char > * get_ivals_ ( ) 
{ return & ivals_ ; } 
} ; 


template < > 
class numpunct_impl < wchar_t > : 
public numpunct_data < wchar_t > 
{ 

static numpunct_init < wchar_t > ivals_ ; 




protected : 
numpunct_impl 
( const numpunct_init < wchar_t > * init ) : 
numpunct_data < wchar_t > ( init ) { } 
public : 
static const numpunct_init < wchar_t > * get_ivals_ ( ) 
{ return & ivals_ ; } 
} ; 



} namespace std { 
#211
template < class charT , class InputIterator > 
class num_get : public locale :: facet 
{ 
public : 
typedef charT char_type ; 
typedef InputIterator iter_type ; 

num_get ( size_t refs = 0 ) : locale :: facet ( refs , locale :: numeric ) { } 


iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
bool & v ) const { return do_get ( i , e , f , err , v ) ; } 

iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
long & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
unsigned short & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
unsigned int & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
unsigned long & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
float & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
double & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
long double & v ) const { return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
void * & p ) const { return do_get ( i , e , f , err , p ) ; } 

static locale :: id id ; 



iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
long long & v ) const 
{ return do_get ( i , e , f , err , v ) ; } 
iter_type get ( iter_type i , iter_type e , ios_base & f , ios_base :: iostate & err , 
unsigned long long & v ) const 
{ return do_get ( i , e , f , err , v ) ; } 



enum { __facet_cat = locale :: numeric , __ok_implicit = 1 } ; 

protected : 
virtual ~ num_get ( ) ; 


virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , bool & v ) const ; 

virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , long & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , unsigned short & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , unsigned int & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , unsigned long & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , float & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , double & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , long double & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , void * & p ) const ; 


virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , 
long long & v ) const ; 
virtual iter_type do_get ( iter_type , iter_type , ios_base & , 
ios_base :: iostate & err , 
unsigned long long & v ) const ; 




private : 

locale :: id & __get_id ( void ) const { return id ; } 

} ; 





template < class charT , class OutputIterator > 
class num_put : public locale :: facet { 
public : 
typedef charT char_type ; 
typedef OutputIterator iter_type ; 

num_put ( size_t refs = 0 ) : locale :: facet ( refs , locale :: numeric ) { } 


iter_type put ( iter_type s , ios_base & f , char_type fill , bool v ) 
const { return do_put ( s , f , fill , v ) ; } 

iter_type put ( iter_type s , ios_base & f , char_type fill , long v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , unsigned long v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , double v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , long double v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , const void * p ) 
const { return do_put ( s , f , fill , p ) ; } 
#330
iter_type put ( iter_type s , ios_base & f , char_type fill , short v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , unsigned short v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , int v ) 
const { return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , unsigned int v ) 
const { return do_put ( s , f , fill , v ) ; } 



iter_type put ( iter_type s , ios_base & f , char_type fill , 
long long v ) const 
{ return do_put ( s , f , fill , v ) ; } 
iter_type put ( iter_type s , ios_base & f , char_type fill , 
unsigned long long v ) const 
{ return do_put ( s , f , fill , v ) ; } 


static locale :: id id ; 


enum { __facet_cat = locale :: numeric , __ok_implicit = 1 } ; 

protected : 
virtual ~ num_put ( ) ; 


virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
bool v ) const ; 

virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
long v ) const ; 
virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
unsigned long v ) 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 * p ) const ; 



virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
short v ) const ; 
virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
unsigned short v ) const ; 
virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
int v ) const ; 
virtual iter_type do_put ( iter_type , ios_base & , char_type fill , 
unsigned int v ) 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 v ) const ; 




private : 

locale :: id & __get_id ( void ) const { return id ; } 

} ; 





template < class charT > 
class numpunct : public locale :: facet , 
public __rwstd :: numpunct_impl < charT > 
{ 
public : 
typedef charT char_type ; 
typedef basic_string < charT , char_traits < charT > , allocator < charT > > 
string_type ; 



numpunct ( size_t refs = 0 , 

const __rwstd :: numpunct_init < charT > * i = __rwstd :: numpunct_impl < charT > :: get_ivals_ ( ) ) ; 





char_type decimal_point ( ) const { return do_decimal_point ( ) ; } 
char_type thousands_sep ( ) const { return do_thousands_sep ( ) ; } 
string grouping ( ) const { return do_grouping ( ) ; } 
string_type truename ( ) const { return do_truename ( ) ; } 
string_type falsename ( ) const { return do_falsename ( ) ; } 

static locale :: id id ; 


enum { __facet_cat = locale :: numeric , __ok_implicit = 1 } ; 

protected : 
virtual ~ numpunct ( ) ; 

virtual char_type do_decimal_point ( ) const ; 
virtual char_type do_thousands_sep ( ) const ; 
virtual string do_grouping ( ) const ; 
virtual string_type do_truename ( ) const ; 
virtual string_type do_falsename ( ) const ; 



private : 
void __initfacet ( const locale * ) ; 


locale :: id & __get_id ( void ) const { return id ; } 

} ; 

template < class charT > 
inline numpunct < charT > :: numpunct 
( size_t refs , const __rwstd :: numpunct_init < charT > * init ) : 
locale :: facet ( refs , locale :: numeric ) , 
__rwstd :: numpunct_impl < charT > ( init ) 
{ } 





template < class charT > 
class numpunct_byname : public numpunct < charT > { 
public : 
numpunct_byname ( const char * , size_t refs = 0 ) ; 

protected : 
virtual ~ numpunct_byname ( ) ; 
#477
} ; 


} namespace __rwstd { 
#490
inline std :: numpunct < char > * create_named_facet 
( std :: numpunct < char > * , const char * name , size_t refs ) 
{ return new std :: numpunct_byname < char > ( name , refs ) ; } 


inline std :: numpunct < wchar_t > * create_named_facet 
( std :: numpunct < wchar_t > * , const char * name , size_t refs ) 
{ return new std :: numpunct_byname < wchar_t > ( name , refs ) ; } 




} 
#42 "/opt/SUNWspro/SC5.0/include/CC/rw/vendor"
namespace __rwstd { 
#58
inline std :: ctype < char > * create_native_facet ( std :: ctype < char > * ) { 
return new std :: ctype < char > ( 0 , false , 1 ) ; 
} 

inline std :: numpunct < char > * create_native_facet ( std :: numpunct < char > * ) { 
return new std :: numpunct_byname < char > ( "" , 1 ) ; 
} 




template < class Facet > 
inline Facet * create_native_facet ( Facet * ) { 
return create_named_facet ( ( Facet * ) 0 , "" , ( size_t ) 1 ) ; 
} 


} 
#42 "/opt/SUNWspro/SC5.0/include/CC/rw/codecvt"
namespace std { 


class codecvt_base { 
public : 
enum result { ok , partial , error , noconv } ; 
} ; 





template < > 
class codecvt < char , char , mbstate_t > : 
public locale :: facet , public codecvt_base 
{ 
public : 
typedef char extern_type ; 
typedef char intern_type ; 
typedef mbstate_t state_type ; 

codecvt ( size_t refs = 0 ) : 
locale :: facet ( refs , locale :: __rw_ctype_category ) { } 

result out ( mbstate_t & state , 
const char * from , const char * from_end , const char * & from_next , 
char * to , char * to_limit , char * & to_next ) const 
{ return do_out ( state , from , from_end , from_next , to , to_limit , to_next ) ; } 

result unshift ( mbstate_t & state , 
char * to , char * to_limit , char * & to_next ) const 
{ return do_unshift ( state , to , to_limit , to_next ) ; } 

result in ( mbstate_t & state , 
const char * from , const char * from_end , const char * & from_next , 
char * to , char * to_limit , char * & to_next ) const 
{ return do_in ( state , from , from_end , from_next , to , to_limit , to_next ) ; } 

int encoding ( ) const throw ( ) 
{ return do_encoding ( ) ; } 

bool always_noconv ( ) const throw ( ) 
{ return do_always_noconv ( ) ; } 

int length ( const mbstate_t & state , const char * from , const char * end , 
size_t max ) const { return do_length ( state , from , end , max ) ; } 

int max_length ( ) const throw ( ) 
{ return do_max_length ( ) ; } 


static locale :: id id ; 





typedef string internal_string_type ; 
typedef string external_string_type ; 
internal_string_type in ( const external_string_type & s ) const { return s ; } 
external_string_type out ( const internal_string_type & s ) const { return s ; } 


enum { __facet_cat = locale :: __rw_ctype_category , __ok_implicit = 1 } ; 

protected : 
virtual ~ codecvt ( ) ; 

virtual result do_out ( mbstate_t & state , 
const char * from , const char * from_end , const char * & from_next , 
char * to , char * to_limit , char * & to_next ) const ; 

virtual result do_in ( mbstate_t & state , 
const char * from , const char * from_end , const char * & from_next , 
char * to , char * to_limit , char * & to_next ) const ; 

virtual result do_unshift ( mbstate_t & state , 
char * to , char * to_limit , char * & to_next ) const ; 

virtual int do_encoding ( ) const throw ( ) ; 

virtual bool do_always_noconv ( ) const throw ( ) ; 

virtual int do_length ( const mbstate_t & , const char * from , const char * end , 
size_t max ) const ; 

virtual int do_max_length ( ) const throw ( ) ; 

private : 

locale :: id & __get_id ( void ) const { return id ; } 

} ; 


template < > 
class codecvt < wchar_t , char , mbstate_t > : 
public locale :: facet , public codecvt_base 
{ 
public : 
typedef wchar_t intern_type ; 
typedef char extern_type ; 
typedef mbstate_t state_type ; 

codecvt ( size_t refs = 0 ) : 
locale :: facet ( refs , locale :: __rw_ctype_category ) { } 

result out ( mbstate_t & state , 
const wchar_t * from , const wchar_t * from_end , const wchar_t * & from_next , 
char * to , char * to_limit , char * & to_next ) const 
{ return do_out ( state , from , from_end , from_next , to , to_limit , to_next ) ; } 

result unshift ( mbstate_t & state , 
char * to , char * to_limit , char * & to_next ) const 
{ return do_unshift ( state , to , to_limit , to_next ) ; } 

result in ( mbstate_t & state , 
const char * from , const char * from_end , const char * & from_next , 
wchar_t * to , wchar_t * to_limit , wchar_t * & to_next ) const 
{ return do_in ( state , from , from_end , from_next , to , to_limit , to_next ) ; } 

int encoding ( ) const throw ( ) 
{ return do_encoding ( ) ; } 

bool always_noconv ( ) const throw ( ) 
{ return do_always_noconv ( ) ; } 

int length ( const mbstate_t & state , const char * from , const char * end , 
size_t max ) const 
{ return do_length ( state , from , end , max ) ; } 

int max_length ( ) const throw ( ) 
{ return do_max_length ( ) ; } 


static locale :: id id ; 





typedef string external_string_type ; 
typedef wstring internal_string_type ; 
internal_string_type in ( const external_string_type & s ) const ; 
external_string_type out ( const internal_string_type & s ) const ; 


enum { __facet_cat = locale :: __rw_ctype_category , __ok_implicit = 1 } ; 

protected : 
virtual ~ codecvt ( ) ; 

virtual result do_out ( mbstate_t & state , 
const wchar_t * from , const wchar_t * from_end , const wchar_t * & from_next , 
char * to , char * to_limit , char * & to_next ) const ; 

virtual result do_in ( mbstate_t & state , 
const char * from , const char * from_end , const char * & from_next , 
wchar_t * to , wchar_t * to_limit , wchar_t * & to_next ) const ; 

virtual result do_unshift ( mbstate_t & state , 
char * to , char * to_limit , char * & to_next ) const ; 

virtual bool do_always_noconv ( ) const throw ( ) ; 

virtual int do_encoding ( ) const throw ( ) ; 

virtual int do_length ( const mbstate_t & , const char * from , 
const char * end , size_t max ) const ; 

virtual int do_max_length ( ) const throw ( ) ; 

private : 

locale :: id & __get_id ( void ) const { return id ; } 

} ; 



template < class internT , class externT , class stateT > 
class codecvt : public locale :: facet , public codecvt_base { 
public : 
typedef internT intern_type ; 
typedef externT extern_type ; 
typedef stateT state_type ; 

codecvt ( size_t refs = 0 ) : locale :: facet ( refs ) { } 

result out ( stateT & state , 
const internT * from , const internT * from_end , const internT * & from_next , 
externT * to , externT * to_limit , externT * & to_next ) const 
{ return do_out ( state , from , from_end , from_next , to , to_limit , to_next ) ; } 

result unshift ( stateT & state , 
externT * to , externT * to_limit , externT * & to_next ) const 
{ return do_unshift ( state , to , to_limit , to_next ) ; } 

result in ( stateT & state , 
const externT * from , const externT * from_end , const externT * & from_next , 
internT * to , internT * to_limit , internT * & to_next ) const 
{ return do_in ( state , from , from_end , from_next , to , to_limit , to_next ) ; } 

bool always_noconv ( ) const throw ( ) 
{ return do_always_noconv ( ) ; } 

int encoding ( ) const throw ( ) 
{ return do_encoding ( ) ; } 

int length ( const stateT & state , const externT * from , const externT * end , 
size_t max ) const 
{ return do_length ( state , from , end , max ) ; } 

int max_length ( ) const throw ( ) 
{ return do_max_length ( ) ; } 

static locale :: id id ; 


typedef basic_string < externT , char_traits < externT > , allocator < externT > > 
external_string_type ; 
typedef basic_string < internT , char_traits < internT > , allocator < internT > > 
internal_string_type ; 
internal_string_type in ( const external_string_type & s ) const ; 
external_string_type out ( const internal_string_type & s ) const ; 


enum { __facet_cat = locale :: __rw_ctype_category , __ok_implicit = 1 } ; 

protected : 
virtual ~ codecvt ( ) ; 

virtual result do_out ( stateT & state , 
const internT * from , const internT * from_end , const internT * & from_next , 
externT * to , externT * to_limit , externT * & to_next ) const ; 

virtual result do_in ( stateT & state , 
const externT * from , const externT * from_end , const externT * & from_next , 
internT * to , internT * to_limit , internT * & to_next ) const ; 

virtual result do_unshift ( stateT & state , 
externT * to , externT * to_limit , externT * & to_next ) const ; 

virtual int do_encoding ( ) const throw ( ) ; 

virtual bool do_always_noconv ( ) const throw ( ) ; 

virtual int do_length ( const stateT & , const externT * from , const externT * end , 
size_t max ) const ; 

virtual int do_max_length ( ) const throw ( ) ; 

private : 

locale :: id & __get_id ( void ) const { return id ; } 

} ; 

template < class internT , class externT , class stateT > 
class codecvt_byname : public codecvt < internT , externT , stateT > { 
public : 

typedef internT intern_type ; 
typedef externT extern_type ; 
typedef stateT state_type ; 

codecvt_byname ( const char * , size_t refs = 0 ) ; 

protected : 
virtual ~ codecvt_byname ( ) ; 

virtual codecvt_base :: result do_out ( stateT & , 
const internT * , const internT * , const internT * & , 
externT * , externT * , externT * & ) const ; 

virtual codecvt_base :: result do_in ( stateT & , 
const externT * , const externT * , const externT * & , 
internT * , internT * , internT * & ) const ; 

virtual codecvt_base :: result do_unshift ( stateT & , 
externT * , externT * , externT * & ) const ; 

virtual int do_encoding ( ) const throw ( ) ; 

virtual bool do_always_noconv ( ) const throw ( ) ; 





} ; 


} 
#39 "/opt/SUNWspro/SC5.0/include/CC/rw/usefacet"
namespace std { 
#52
template < class Facet > 
inline 
const Facet & use_facet ( const locale & loc , Facet * ) 
{ 



size_t i = ( const locale :: id & ) Facet :: id ; 


const __rwstd :: facet_imp * f = loc . get_facet ( i ) ; 





if ( ! f ) 
f = loc . __make_explicit ( Facet :: id , Facet :: __ok_implicit , Facet :: __facet_cat , 
__rwstd :: facet_maker < Facet > :: maker_func ) ; 

return ( const Facet & ) * f ; 
} 





template < class Facet > 
inline bool has_facet ( const locale & loc , Facet * ) 
throw ( ) 
{ 
size_t ix = ( const locale :: id & ) Facet :: id ; 
return loc . __imp -> get_facet ( ix ) != 0 || Facet :: __ok_implicit ; 
} 
#121
template < class charT > inline bool isspace ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: space , c ) ; } 
template < class charT > inline bool isprint ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: print , c ) ; } 
template < class charT > inline bool iscntrl ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: cntrl , c ) ; } 
template < class charT > inline bool isupper ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: upper , c ) ; } 
template < class charT > inline bool islower ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: lower , c ) ; } 
template < class charT > inline bool isalpha ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: alpha , c ) ; } 
template < class charT > inline bool isdigit ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: digit , c ) ; } 
template < class charT > inline bool ispunct ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: punct , c ) ; } 
template < class charT > inline bool isxdigit ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: xdigit , c ) ; } 
template < class charT > inline bool isalnum ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: alnum , c ) ; } 
template < class charT > inline bool isgraph ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . is ( ctype_base :: graph , c ) ; } 

template < class charT > inline charT toupper ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . toupper ( c ) ; } 
template < class charT > inline charT tolower ( charT c , const locale & loc ) 
{ return use_facet ( loc , ( ctype < charT > * ) 0 ) . tolower ( c ) ; } 




} 
#45 "/opt/SUNWspro/SC5.0/include/CC/./ios"
namespace __rwstd { 



extern const unsigned int rwse_failbit_set ; 
extern const unsigned int rwse_badbit_set ; 
extern const unsigned int rwse_eofbit_set ; 
#60
} 
namespace std { 
#68
template < class charT , class traits > 
class basic_ios : public ios_base 
{ 

public : 



typedef typename traits :: char_type 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_ios < charT , traits > ios_type ; 
typedef basic_streambuf < charT , traits > streambuf_type ; 
typedef basic_ostream < charT , traits > ostream_type ; 

inline operator void * ( ) const ; 
inline bool operator ! ( ) const ; 
inline iostate rdstate ( ) const ; 
inline void clear ( iostate state = goodbit ) ; 
inline void setstate ( iostate state ) ; 

inline bool good ( ) const ; 
inline bool eof ( ) const ; 
inline bool fail ( ) const ; 
inline bool bad ( ) const ; 

inline iostate exceptions ( ) const ; 
inline void exceptions ( iostate excpt ) ; 

basic_ios ( basic_streambuf < charT , traits > * sb_arg ) ; 
virtual ~ basic_ios ( ) ; 

inline ostream_type * tie ( ) const ; 
ostream_type * tie ( ostream_type * tie_arg ) ; 

inline streambuf_type * rdbuf ( ) const ; 
streambuf_type * rdbuf ( streambuf_type * sb ) ; 

ios_type & copyfmt ( const ios_type & rhs ) ; 

char_type fill ( ) const 
{ 
return __fillch ; 
} 
char_type fill ( char_type ch ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

char_type temp = __fillch ; 
__fillch = ch ; 
return temp ; 
} 


locale imbue ( const locale & loc ) ; 

inline char narrow ( charT , char ) const ; 
inline charT widen ( char ) const ; 

protected : 
basic_ios ( ) ; 
basic_ios ( int ) : ios_base ( 1 ) { } 
void init ( basic_streambuf < charT , traits > * sb ) ; 

inline void _RW_UNSAFE_clear ( iostate state = goodbit ) ; 

private : 
basic_ios ( const basic_ios & ) ; 
basic_ios & operator = ( const basic_ios & ) ; 

streambuf_type * __sb ; 
ostream_type * __tiestr ; 
char_type __fillch ; 
iostate __state ; 
iostate _Except ; 

} ; 
#156
template < class charT , class traits > 
inline basic_streambuf < charT , traits > * 
basic_ios < charT , traits > :: rdbuf ( ) const 
{ 
return __sb ; 
} 





template < class charT , class traits > 
inline basic_ostream < charT , traits > * 
basic_ios < charT , traits > :: tie ( ) const 
{ 
return __tiestr ; 
} 





template < class charT , class traits > 
inline void 
basic_ios < charT , traits > :: exceptions ( ios_base :: iostate st ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

_Except = st ; 


_RW_UNSAFE_clear ( rdstate ( ) ) ; 



} 





template < class charT , class traits > 
inline ios_base :: iostate 
basic_ios < charT , traits > :: exceptions ( ) const 
{ 
return _Except ; 
} 





template < class charT , class traits > 
inline void 
basic_ios < charT , traits > :: clear ( iostate st ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 

_RW_UNSAFE_clear ( st ) ; 
} 





template < class charT , class traits > 
inline void 
basic_ios < charT , traits > :: setstate ( iostate st ) 
{ 

_RWSTDGuard guard ( this -> __stream_mutex ) ; 



_RW_UNSAFE_clear ( __state | st ) ; 



} 





template < class charT , class traits > 
inline ios_base :: iostate 
basic_ios < charT , traits > :: rdstate ( ) const 
{ 
return __state ; 
} 





template < class charT , class traits > 
inline basic_ios < charT , traits > :: operator void * ( ) const 
{ 
return fail ( ) ? ( void * ) 0 : ( void * ) 1 ; 
} 





template < class charT , class traits > 
inline bool 
basic_ios < charT , traits > :: operator ! ( ) const 
{ 
return fail ( ) ; 
} 





template < class charT , class traits > 
inline bool 
basic_ios < charT , traits > :: good ( ) const 
{ 
return ( __state == ios_base :: goodbit ) ; 
} 





template < class charT , class traits > 
inline bool 
basic_ios < charT , traits > :: eof ( ) const 
{ 
return ( __state & ios_base :: eofbit ) ; 
} 





template < class charT , class traits > 
inline bool 
basic_ios < charT , traits > :: fail ( ) const 
{ 
return ( __state & ( ios_base :: failbit | ios_base :: badbit ) ) ; 
} 





template < class charT , class traits > 
inline bool 
basic_ios < charT , traits > :: bad ( ) const 
{ 
return ( __state & ios_base :: badbit ) ; 
} 





template < class charT , class traits > 
inline void 
basic_ios < charT , traits > :: _RW_UNSAFE_clear ( iostate st ) 
{ 
if ( ! __sb ) 
{ 
st |= ios_base :: badbit ; 
__state |= ios_base :: badbit ; 
} 

__state = st ; 

if ( rdstate ( ) & exceptions ( ) ) 
{ 


if ( rdstate ( ) & exceptions ( ) & ios_base :: failbit ) 
{ 
__state = st ; 
throw ios_base :: failure ( string ( __rwstd :: except_msg_string ( __rwstd :: rwse_failbit_set ) . msgstr ( ) ) ) ; 
} 

if ( rdstate ( ) & exceptions ( ) & ios_base :: badbit ) 
{ 
__state = st ; 
throw ios_base :: failure ( string ( __rwstd :: except_msg_string ( __rwstd :: rwse_badbit_set ) . msgstr ( ) ) ) ; 
} 
if ( rdstate ( ) & exceptions ( ) & ios_base :: eofbit ) 
{ 
__state = st ; 
throw ios_base :: failure ( string ( __rwstd :: except_msg_string ( __rwstd :: rwse_eofbit_set ) . msgstr ( ) ) ) ; 
} 


} 
} 





template < class charT , class traits > 
inline char 
basic_ios < charT , traits > :: narrow ( charT c , char dfault ) const 
{ 



return use_facet ( getloc ( ) , ( ctype < charT > * ) 0 ) . narrow ( c , dfault ) ; 


} 





template < class charT , class traits > 
inline charT 
basic_ios < charT , traits > :: widen ( char c ) const 
{ 



return use_facet ( getloc ( ) , ( ctype < charT > * ) 0 ) . widen ( c ) ; 


} 


typedef basic_ios < char > ios ; 
#395
typedef basic_ios < wchar_t > wios ; 
#406
template < class charT , class traits > 
basic_ios < charT , traits > & __lock ( basic_ios < charT , traits > & ) ; 

template < class charT , class traits > 
basic_ios < charT , traits > & __unlock ( basic_ios < charT , traits > & ) ; 




} 
#44 "/opt/SUNWspro/SC5.0/include/CC/./streambuf"
namespace std { 


template < class charT , class traits > 
class basic_streambuf { 

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 ; 

virtual ~ basic_streambuf ( ) ; 

locale pubimbue ( const locale & loc ) ; 
locale getloc ( ) const ; 

inline basic_streambuf < char_type , traits > * 
pubsetbuf ( char_type * s , streamsize n ) ; 

inline pos_type pubseekoff ( off_type off , ios_base :: seekdir way , 
ios_base :: openmode which = 
ios_base :: in | ios_base :: out ) ; 

inline pos_type pubseekpos ( pos_type sp , ios_base :: openmode which = 
ios_base :: in | ios_base :: out ) ; 

inline int pubsync ( ) ; 
inline ios_base :: openmode which_open_mode ( ) ; 
inline streamsize in_avail ( ) ; 

inline int_type snextc ( ) ; 
inline int_type sbumpc ( ) ; 
inline int_type sgetc ( ) ; 
inline streamsize sgetn ( char_type * s , streamsize n ) ; 

inline int_type sputbackc ( char_type c ) ; 
inline int_type sungetc ( ) ; 

inline int_type sputc ( char_type c ) ; 
inline streamsize sputn ( const char_type * s , streamsize n ) ; 


_RWSTDMutex buffer_mutex_ ; 

void _RW_lock_buffer ( ) 
{ 
_RWSTDGuard * tmp = new _RWSTDGuard ( buffer_mutex_ ) ; 
if ( tmp ) 
__buffer_guard = tmp ; 
else 
__buffer_guard = 0 ; 
} 

void _RW_unlock_buffer ( ) 
{ 
if ( __buffer_guard ) 
{ 
_RWSTDGuard * tmp = __buffer_guard ; 
__buffer_guard = 0 ; 
delete tmp ; 
} 
} 


protected : 
basic_streambuf ( ) ; 

ios_base :: openmode mode_ ; 

inline char_type * eback ( ) const ; 
inline char_type * gptr ( ) const ; 
inline char_type * egptr ( ) const ; 
inline void gbump ( int n ) ; 
inline void setg ( char_type * gbeg_arg , char_type * gnext_arg , char_type * gend_arg ) ; 

inline char_type * pbase ( ) const ; 
inline char_type * pptr ( ) const ; 
inline char_type * epptr ( ) const ; 
inline void pbump ( int n ) ; 
inline void setp ( char_type * pbeg_arg , char_type * pend_arg ) ; 

virtual void imbue ( const locale & loc ) ; 

virtual basic_streambuf < charT , traits > * 
setbuf ( char_type * s , streamsize n ) ; 

virtual pos_type seekoff ( off_type off , 
ios_base :: seekdir way , ios_base :: openmode which = 
ios_base :: in | ios_base :: out ) ; 

virtual pos_type seekpos ( pos_type sp , 
ios_base :: openmode which = 
ios_base :: in | ios_base :: out ) ; 

virtual streamsize showmanyc ( ) ; 
virtual streamsize xsgetn ( char_type * s , streamsize n ) ; 
virtual int_type underflow ( ) ; 
virtual int_type uflow ( ) ; 
virtual int_type overflow ( int_type c = traits :: eof ( ) ) ; 

virtual int_type pbackfail ( int_type c = traits :: eof ( ) ) ; 
virtual streamsize xsputn ( const char_type * s , streamsize n ) ; 

virtual int sync ( ) ; 
void streambuf_init ( bool set_mode = true ) ; 

private : 

char_type * __gbeg ; 
char_type * __gnext ; 
char_type * __gend ; 

char_type * __pbeg ; 
char_type * __pnext ; 
char_type * __pend ; 

locale __loc_buf ; 


_RWSTDGuard * __buffer_guard ; 

} ; 
#182
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: int_type 
basic_streambuf < charT , traits > :: snextc ( ) 
{ 
if ( traits :: eq_int_type ( sbumpc ( ) , traits :: eof ( ) ) ) 
return traits :: eof ( ) ; 

return sgetc ( ) ; 
} 
#197
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: int_type 
basic_streambuf < charT , traits > :: sbumpc ( ) 
{ 
char_type c ; 

if ( gptr ( ) >= egptr ( ) ) { 
return uflow ( ) ; 
} 
c = * gptr ( ) ; 
gbump ( 1 ) ; 
return traits :: to_int_type ( c ) ; 
} 
#216
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: int_type 
basic_streambuf < charT , traits > :: sgetc ( ) 
{ 

if ( gptr ( ) >= egptr ( ) ) { 
return underflow ( ) ; 
} 

return traits :: to_int_type ( * gptr ( ) ) ; 
} 
#233
template < class charT , class traits > 
inline streamsize basic_streambuf < charT , traits > :: 
sgetn ( char_type * s , streamsize n ) 
{ 
return xsgetn ( s , n ) ; 
} 
#245
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: int_type 
basic_streambuf < charT , traits > :: sputbackc ( char_type c ) 
{ 
if ( gptr ( ) > eback ( ) ) 
{ 
gbump ( - 1 ) ; 
if ( ! traits :: eq ( * gptr ( ) , c ) ) 
{ 
gbump ( 1 ) ; 
return pbackfail ( traits :: to_int_type ( c ) ) ; 
} 

return traits :: to_int_type ( * gptr ( ) ) ; 
} 

return pbackfail ( traits :: to_int_type ( c ) ) ; 
} 
#270
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: int_type 
basic_streambuf < charT , traits > :: sungetc ( ) 
{ 
if ( gptr ( ) > eback ( ) ) 
{ 
gbump ( - 1 ) ; 
return traits :: to_int_type ( * gptr ( ) ) ; 
} 
return pbackfail ( ) ; 
} 
#287
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: int_type 
basic_streambuf < charT , traits > :: sputc ( char_type c ) 
{ 

if ( pptr ( ) >= epptr ( ) ) 
{ 
return overflow ( traits :: to_int_type ( c ) ) ; 
} 
* __pnext ++ = c ; 
return traits :: to_int_type ( c ) ; 
} 
#305
template < class charT , class traits > 
inline streamsize 
basic_streambuf < charT , traits > :: sputn ( const char_type * s , streamsize n ) 
{ 
return xsputn ( s , n ) ; 
} 
#318
template < class charT , class traits > 
inline void 
basic_streambuf < charT , traits > :: gbump ( int n ) 
{ 
__gnext += n ; 
} 
#330
template < class charT , class traits > 
inline void 
basic_streambuf < charT , traits > :: 
setg ( char_type * gbeg , char_type * gnext , char_type * gend ) 
{ 
__gbeg = gbeg ; 
__gnext = gnext ; 
__gend = gend ; 
} 
#345
template < class charT , class traits > 
inline void 
basic_streambuf < charT , traits > :: pbump ( int n ) 
{ 
__pnext += n ; 
} 
#357
template < class charT , class traits > 
inline void 
basic_streambuf < charT , traits > :: 
setp ( char_type * pbeg , char_type * pend ) 
{ 
__pbeg = pbeg ; 
__pnext = pbeg ; 
__pend = pend ; 
} 
#372
template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: char_type * 
basic_streambuf < charT , traits > :: eback ( ) const 
{ 
return __gbeg ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: char_type * 
basic_streambuf < charT , traits > :: gptr ( ) const 
{ 
return __gnext ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: char_type * 
basic_streambuf < charT , traits > :: egptr ( ) const 
{ 
return __gend ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: char_type * 
basic_streambuf < charT , traits > :: pbase ( ) const 
{ 
return __pbeg ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: char_type * 
basic_streambuf < charT , traits > :: pptr ( ) const 
{ 
return __pnext ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: char_type * 
basic_streambuf < charT , traits > :: epptr ( ) const 
{ 
return __pend ; 
} 
#439
template < class charT , class traits > 
inline streamsize 
basic_streambuf < charT , traits > :: in_avail ( ) 
{ 
if ( gptr ( ) >= egptr ( ) ) 
return showmanyc ( ) ; 

return ( ( streamsize ) ( egptr ( ) - gptr ( ) ) ) ; 
} 





template < class charT , class traits > 
inline int 
basic_streambuf < charT , traits > :: pubsync ( ) 
{ 
return sync ( ) ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: pos_type 
basic_streambuf < charT , traits > :: 
pubseekoff ( off_type off , ios_base :: seekdir way , ios_base :: openmode which ) 
{ 
return seekoff ( off , way , which ) ; 
} 





template < class charT , class traits > 
inline typename basic_streambuf < charT , traits > :: pos_type 
basic_streambuf < charT , traits > :: 
pubseekpos ( pos_type sp , 
ios_base :: openmode which ) 
{ 
return seekpos ( sp , which ) ; 
} 





template < class charT , class traits > 
inline basic_streambuf < charT , traits > * 
basic_streambuf < charT , traits > :: 
pubsetbuf ( char_type * s , streamsize n ) 
{ 
return setbuf ( s , n ) ; 
} 





template < class charT , class traits > 
inline ios_base :: openmode 
basic_streambuf < charT , traits > :: which_open_mode ( ) 
{ 
return mode_ ; 
} 
#516
template < class charT , class traits > 
class ostreambuf_iterator 
: public iterator < output_iterator_tag , charT , 
typename traits :: off_type , charT * , charT & > 
{ 

public : 



typedef charT char_type ; 
typedef traits traits_type ; 
typedef basic_streambuf < charT , traits > streambuf_type ; 
typedef basic_ostream < charT , traits > ostream_type ; 

ostreambuf_iterator ( ostream_type & s ) throw ( ) 
: __sbuf ( s . rdbuf ( ) ) 
{ 
if ( s . rdbuf ( ) ) __failed_flag = false ; 
else 
__failed_flag = true ; 
} 

ostreambuf_iterator ( streambuf_type * s ) throw ( ) 
: __sbuf ( s ) 
{ 
if ( s ) __failed_flag = false ; 
else 
__failed_flag = true ; 
} 

ostreambuf_iterator < charT , traits > & operator * ( ) 
{ return * this ; } 
ostreambuf_iterator < charT , traits > & operator ++ ( ) 
{ return * this ; } 
ostreambuf_iterator < charT , traits > operator ++ ( int ) 
{ return * this ; } 

ostreambuf_iterator < charT , traits > & operator = ( charT c ) 
{ 
if ( ! __failed_flag ) 
{ 
if ( traits :: eq_int_type ( __sbuf -> sputc ( c ) , traits :: eof ( ) ) ) 
__failed_flag = true ; 
} 
return * this ; 
} 

bool failed ( ) const throw ( ) 
{ return __failed_flag ; } 

protected : 

private : 
streambuf_type * __sbuf ; 
bool __failed_flag ; 
} ; 





template < class charT , class traits > 
class istreambuf_iterator 
: public iterator < input_iterator_tag , charT , 
typename traits :: off_type , charT * , charT & > 
{ 

public : 



typedef charT char_type ; 
typedef typename traits :: int_type int_type ; 
typedef traits traits_type ; 

typedef basic_streambuf < charT , traits > streambuf_type ; 
typedef basic_istream < charT , traits > istream_type ; 


class proxy { 
char_type __keep ; 
streambuf_type * __sbuf ; 

proxy ( char_type c , streambuf_type * sbuf ) 
: __keep ( c ) , __sbuf ( sbuf ) 
{ ; } 

public : 

char_type operator * ( ) 
{ return __keep ; } 

friend class istreambuf_iterator < charT , traits > ; 
} ; 

public : 

istreambuf_iterator ( ) throw ( ) 
: __sbuf ( 0 ) 
{ __failed_flag = true ; } 
istreambuf_iterator ( istream_type & s ) throw ( ) 
: __sbuf ( s . rdbuf ( ) ) 
{ 
if ( s . rdbuf ( ) ) __failed_flag = false ; 
else 
__failed_flag = true ; 
} 
istreambuf_iterator ( streambuf_type * s ) throw ( ) 
: __sbuf ( s ) 
{ 
if ( s ) __failed_flag = false ; 
else 
__failed_flag = true ; 
} 
istreambuf_iterator ( const proxy & p ) throw ( ) 
: __sbuf ( p . __sbuf ) 
{ ; } 
inline char_type operator * ( ) ; 
inline istreambuf_iterator < charT , traits > & operator ++ ( ) ; 
inline proxy operator ++ ( int ) ; 
inline bool equal ( istreambuf_iterator < charT , traits > & b ) ; 

bool failed ( ) const throw ( ) 
{ return __failed_flag ; } 

protected : 

private : 
streambuf_type * __sbuf ; 
bool __failed_flag ; 
} ; 
#657
template < class charT , class traits > 
inline typename istreambuf_iterator < charT , traits > :: char_type 
istreambuf_iterator < charT , traits > :: operator * ( ) 
{ 
int_type c ; 

if ( __sbuf && ! __failed_flag ) 
{ 
c = __sbuf -> sgetc ( ) ; 
if ( traits :: eq_int_type ( c , traits :: eof ( ) ) ) 
{ 
__sbuf = 0 ; 
__failed_flag = true ; 
} 
} 
else return traits :: eof ( ) ; 

return traits :: to_char_type ( c ) ; 
} 





template < class charT , class traits > 
inline istreambuf_iterator < charT , traits > & 
istreambuf_iterator < charT , traits > :: operator ++ ( ) 
{ 
if ( __sbuf && ! __failed_flag ) 
{ 
__sbuf -> sbumpc ( ) ; 
if ( traits :: eq_int_type ( __sbuf -> sgetc ( ) , traits :: eof ( ) ) ) 
{ 
__sbuf = 0 ; 
__failed_flag = true ; 
} 
} 
return * this ; 
} 





template < class charT , class traits > 
inline typename istreambuf_iterator < charT , traits > :: proxy 
istreambuf_iterator < charT , traits > :: operator ++ ( int ) 
{ 

if ( __sbuf && ! __failed_flag ) 
{ 
proxy prev ( __sbuf -> sgetc ( ) , __sbuf ) ; 
__sbuf -> sbumpc ( ) ; 
if ( traits :: eq_int_type ( __sbuf -> sgetc ( ) , traits :: eof ( ) ) ) 
{ 
__sbuf = 0 ; 
__failed_flag = true ; 
} 
return prev ; 
} 

charT c = traits :: to_char_type ( traits :: eof ( ) ) ; 
return proxy ( c , __sbuf ) ; 
} 





template < class charT , class traits > 
inline bool 
istreambuf_iterator < charT , traits > :: 
equal ( istreambuf_iterator < charT , traits > & b ) 
{ 
if ( ( ( __sbuf == 0 ) && ( b . __sbuf == 0 ) ) || ( ( __sbuf != 0 ) && ( b . __sbuf != 0 ) ) ) 
return true ; 
else 
return false ; 
} 





template < class charT , class traits > 
inline bool operator == ( istreambuf_iterator < charT , traits > & a , 
istreambuf_iterator < charT , traits > & b ) 
{ 
return a . equal ( b ) ; 
} 





template < class charT , class traits > 
inline bool operator != ( istreambuf_iterator < charT , traits > & a , 
istreambuf_iterator < charT , traits > & b ) 
{ 
return ! ( a . equal ( b ) ) ; 
} 





typedef basic_streambuf < char > streambuf ; 
#770
typedef basic_streambuf < wchar_t > wstreambuf ; 
#778
} 
#43 "/opt/SUNWspro/SC5.0/include/CC/./ostream"
namespace std { 


extern ostream cout ; 
extern ostream cerr ; 


extern wostream wcout ; 
extern wostream wcerr ; 


template < class charT , class traits > 
inline bool __rw_is_out ( basic_ostream < charT , traits > * s ) ; 
inline bool __rw_is_out ( basic_ostream < char , char_traits < char > > * s ) ; 

inline bool __rw_is_out ( basic_ostream < wchar_t , char_traits < wchar_t > > * s ) ; 

template < class charT , class traits > 
inline bool __rw_is_err ( basic_ostream < charT , traits > * s ) ; 
inline bool __rw_is_err ( basic_ostream < char , char_traits < char > > * s ) ; 

inline bool __rw_is_err ( basic_ostream < wchar_t , char_traits < wchar_t > > * s ) ; 
#71
template < class charT , class 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_ostream < charT , traits > ostream_type ; 
typedef basic_ios < charT , traits > ios_type ; 

basic_ostream ( basic_streambuf < charT , traits > * sb ) ; 
basic_ostream ( EmptyCtor ) : basic_ios < charT , traits > ( 1 ) { } 
virtual ~ basic_ostream ( ) ; 

class sentry { 
public : 
inline 
sentry ( basic_ostream < charT , traits > & stream ) 
: __stream ( stream ) 
{ 


if ( stream . rdbuf ( ) ) { 
__guard = new _RWSTDGuard ( stream . rdbuf ( ) -> buffer_mutex_ ) ; 
} 

try { 


if ( stream . tie ( ) ) 
stream . tie ( ) -> flush ( ) ; 

if ( stream . is_synch ( ) ) 
{ 
if ( __rw_is_out ( & stream ) ) 
{ 
fflush ( ( & __iob [ 1 ] ) ) ; 
} 
if ( __rw_is_err ( & stream ) ) 
{ 
fflush ( ( & __iob [ 2 ] ) ) ; 
} 
} 

if ( stream . rdbuf ( ) ) 
{ 
if ( stream . rdbuf ( ) -> which_open_mode ( ) & ios_base :: app ) 
stream . rdbuf ( ) -> pubseekoff ( 0 , ios_base :: end , ios_base :: out ) ; 
} 

ok_ = stream . good ( ) ; 

if ( ! ok_ ) 
stream . setstate ( ios_base :: badbit ) ; 


} catch ( ... ) 
{ 
if ( __stream . rdbuf ( ) ) 
delete __guard ; 
throw ; 
} 


} 

~ sentry ( ) { 
if ( __stream . flags ( ) & ios_base :: unitbuf ) 
{ 
if ( __stream . rdbuf ( ) -> pubsync ( ) == - 1 ) 
__stream . setstate ( ios_base :: badbit ) ; 
} 

if ( __stream . is_synch ( ) ) 
{ 

if ( __rw_is_out ( & __stream ) || __rw_is_err ( & __stream ) ) 
{ 
if ( __stream . rdbuf ( ) -> pubsync ( ) == - 1 ) 
__stream . setstate ( ios_base :: badbit ) ; 
} 
} 


if ( __stream . rdbuf ( ) ) { 
delete __guard ; 
} 

} 
operator bool ( ) const { return ok_ ; } 

private : 
sentry ( const sentry & ) ; 
sentry & operator = ( const sentry & ) ; 
basic_ostream < charT , traits > & __stream ; 
bool ok_ ; 

_RWSTDGuard * __guard ; 

} ; 

ostream_type & operator << ( ostream_type & ( * pf ) ( ostream_type & ) ) ; 
ostream_type & operator << ( ios_base & ( * pf ) ( ios_base & ) ) ; 
ostream_type & operator << ( ios_type & ( * pf ) ( ios_type & ) ) ; 


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 n ) ; 
ostream_type & operator << ( unsigned long n ) ; 
ostream_type & operator << ( float f ) ; 
ostream_type & operator << ( double f ) ; 
ostream_type & operator << ( long double f ) ; 

ostream_type & operator << ( unsigned long long n ) ; 
ostream_type & operator << ( long long n ) ; 

ostream_type & operator << ( const void * p ) ; 

ostream_type & operator << ( basic_streambuf < char_type , traits > & sb ) 
{ 
ios_base :: iostate err = 0 ; 


try { 

if ( ! ( sb . which_open_mode ( ) & ios_base :: in ) ) 
err = ios_base :: failbit ; 
else 
{ 
typename basic_ostream < charT , traits > :: sentry opfx ( * this ) ; 

if ( opfx ) 
{ 
if ( traits :: eq_int_type ( sb . sgetc ( ) , traits :: eof ( ) ) ) 
err = ios_base :: failbit ; 
else { 
int_type c ; 
while ( ! traits :: eq_int_type ( ( c = sb . sbumpc ( ) ) , traits :: eof ( ) ) ) 
{ 
if ( traits :: eq_int_type ( this -> rdbuf ( ) -> sputc ( c ) , traits :: eof ( ) ) ) 
{ 
err = ios_base :: failbit ; 
break ; 
} 
} 
} 
} 
} 


} 



catch ( ... ) 
{ 
bool flag = false ; 
try { 
this -> setstate ( ios_base :: badbit ) ; 
} 
catch ( ios_base :: failure ) { flag = true ; } 
if ( flag ) throw ; 
} 

if ( err ) this -> setstate ( err ) ; 
return * this ; 
} 

ostream_type & operator << ( basic_streambuf < char_type , traits > * sb ) 
{ 
ios_base :: iostate err = 0 ; 


try { 

if ( sb ) 
{ 
if ( ! ( sb -> which_open_mode ( ) & ios_base :: in ) ) 
err = ios_base :: failbit ; 
else 
{ 
typename basic_ostream < charT , traits > :: sentry opfx ( * this ) ; 

if ( opfx ) 
{ 
if ( traits :: eq_int_type ( sb -> sgetc ( ) , traits :: eof ( ) ) ) 
err = ios_base :: failbit ; 
else { 
int_type c ; 
while ( ! traits :: eq_int_type ( ( c = sb -> sbumpc ( ) ) , traits :: eof ( ) ) ) 
{ 
if ( traits :: eq_int_type ( this -> rdbuf ( ) -> sputc ( c ) , traits :: eof ( ) ) ) 
{ 
err = ios_base :: failbit ; 
break ; 
} 
} 
} 
} 
} 
} 
else 
err = ios_base :: badbit ; 


} 



catch ( ... ) 
{ 
bool flag = false ; 
try { 
this -> setstate ( ios_base :: badbit ) ; 
} 
catch ( ios_base :: failure ) { flag = true ; } 
if ( flag ) throw ; 
} 

if ( err ) this -> setstate ( err ) ; 
return * this ; 
} 

ostream_type & put ( char_type c ) ; 
ostream_type & write ( const char_type * s , streamsize n ) ; 
ostream_type & flush ( ) ; 

ostream_type & seekp ( pos_type pos ) 
{ 

if ( this -> rdbuf ( ) ) { 

_RWSTDGuard guard ( this -> rdbuf ( ) -> buffer_mutex_ ) ; 





if ( this -> fail ( ) ) return * this ; 

this -> rdbuf ( ) -> pubseekpos ( pos , ios_base :: out ) ; 

return * this ; 

} 

} 

ostream_type & seekp ( off_type , ios_base :: seekdir ) ; 
pos_type tellp ( ) ; 


_RWSTDGuard * ostream_sentry_guard ; 

protected : 
basic_ostream ( ) ; 



} ; 



inline bool __rw_is_out ( basic_ostream < char , char_traits < char > > * s ) 
{ return ( void * ) s == ( void * ) & cout ; } 

inline bool __rw_is_out ( basic_ostream < wchar_t , char_traits < wchar_t > > * s ) 
{ return ( void * ) s == ( void * ) & wcout ; } 


inline bool __rw_is_err ( basic_ostream < char , char_traits < char > > * s ) 
{ return ( void * ) s == ( void * ) & cerr ; } 

inline bool __rw_is_err ( basic_ostream < wchar_t , char_traits < wchar_t > > * s ) 
{ return ( void * ) s == ( void * ) & wcerr ; } 


template < class charT , class traits > 
inline bool __rw_is_out ( basic_ostream < charT , traits > * s ) 
{ return false ; } 

template < class charT , class traits > 
inline bool __rw_is_err ( basic_ostream < charT , traits > * s ) 
{ return false ; } 
#374
template < class T , class charT , class traits > 



class ostream_iterator 
: public iterator < output_iterator_tag , T , typename traits :: off_type , T * , T & > 
{ 
protected : 

basic_ostream < charT , traits > * __stream ; 
const charT * __str ; 

public : 



typedef T value_type ; 
typedef charT char_type ; 
typedef traits traits_type ; 
typedef basic_ostream < charT , traits > ostream_type ; 

ostream_iterator ( basic_ostream < charT , traits > & s ) 
: __stream ( & s ) , __str ( 0 ) 
{ ; } 
ostream_iterator ( basic_ostream < charT , traits > & s , const charT * c ) 
: __stream ( & s ) , __str ( ( charT * ) c ) 
{ ; } 
ostream_iterator ( const ostream_iterator < T , charT , traits > & x ) 
: __stream ( x . __stream ) , __str ( x . __str ) 
{ ; } 
ostream_iterator < T , charT , traits > & operator = ( const T & value ) 
{ 
* __stream << ( T ) value ; 
if ( __str ) * __stream << __str ; 
return * this ; 
} 
ostream_iterator < T , charT , traits > & operator * ( ) { return * this ; } 
ostream_iterator < T , charT , traits > & operator ++ ( ) { return * this ; } 
ostream_iterator < T , charT , traits > & operator ++ ( int ) { return * this ; } 
} ; 



typedef basic_ostream < char > ostream ; 
#424
typedef basic_ostream < wchar_t > wostream ; 
#432
template < class charT , class traits > 
basic_ostream < charT , traits > & operator << ( basic_ostream < charT , traits > & , 
charT ) ; 



template < class charT , class traits > 
basic_ostream < charT , traits > & operator << ( basic_ostream < charT , traits > & , 
char ) ; 
#447
ostream & operator << ( ostream & , char ) ; 




template < class charT , class traits > 
basic_ostream < charT , traits > & operator << ( basic_ostream < charT , traits > & , 
const charT * ) ; 



template < class charT , class traits > 
basic_ostream < charT , traits > & operator << ( basic_ostream < charT , traits > & , 
const char * ) ; 
#467
ostream & operator << ( ostream & , const char * ) ; 
#476
template < class traits > 
basic_ostream < char , traits > & operator << ( basic_ostream < char , traits > & , 
unsigned char ) ; 

template < class traits > 
basic_ostream < char , traits > & operator << ( basic_ostream < char , traits > & , 
signed char ) ; 

template < class traits > 
basic_ostream < char , traits > & operator << ( basic_ostream < char , traits > & , 
const unsigned char * ) ; 

template < class traits > 
basic_ostream < char , traits > & operator << ( basic_ostream < char , traits > & , 
const signed char * ) ; 





template < class charT , class traits , class Allocator > 
inline basic_ostream < charT , traits > & 
operator << ( basic_ostream < charT , traits > & os , 
const basic_string < charT , traits , Allocator > & s ) 
{ 
ios_base :: iostate err = 0 ; 


try { 


typename basic_ostream < charT , traits > :: sentry opfx ( os ) ; 
if ( opfx ) 
{ 
int dlen = s . length ( ) ; 
int pad = os . width ( ) - dlen ; 


if ( ! ( os . flags ( ) & ios_base :: adjustfield ) || os . flags ( ) & ios_base :: right ) 
{ 
while ( -- pad >= 0 ) 
{ 
if ( traits :: eq_int_type ( os . rdbuf ( ) -> sputc ( os . fill ( ) ) , traits :: eof ( ) ) ) { 
err = ios_base :: badbit ; 
break ; 
} 
} 
} 


if ( os . good ( ) && ( os . flags ( ) & ios_base :: internal ) ) 
{ 
while ( -- pad >= 0 ) 
{ 
if ( traits :: eq_int_type ( os . rdbuf ( ) -> sputc ( os . fill ( ) ) , traits :: eof ( ) ) ) 
{ 
err = ios_base :: badbit ; 
break ; 
} 
} 
} 

if ( os . good ( ) && dlen ) { 
if ( os . rdbuf ( ) && ( os . rdbuf ( ) -> sputn ( s . c_str ( ) , dlen ) != dlen ) ) 
err = ios_base :: badbit ; 
} 


if ( os . good ( ) && ( os . flags ( ) & ios_base :: left ) ) 
{ 
while ( -- pad >= 0 ) 
{ 
if ( traits :: eq_int_type ( os . rdbuf ( ) -> sputc ( os . fill ( ) ) , traits :: eof ( ) ) ) 
{ 
err = ios_base :: badbit ; 
break ; 
} 
} 
} 

os . width ( 0 ) ; 
} 


} 



catch ( ... ) 
{ 
bool flag = false ; 
try { 
os . setstate ( ios_base :: badbit ) ; 
} 
catch ( ios_base :: failure ) { flag = true ; } 
if ( flag ) throw ; 
} 


if ( err ) os . setstate ( err ) ; 

return os ; 
} 



extern ostream cout ; 
extern ostream cerr ; 
extern ostream clog ; 
#591
template < class charT , class traits > 
inline basic_ostream < charT , traits > & 
endl ( basic_ostream < charT , traits > & os ) 
{ 
os . put ( charT ( '\n' ) ) ; 
os . flush ( ) ; 
return os ; 
} 

template < class charT , class traits > 
inline basic_ostream < charT , traits > & 
ends ( basic_ostream < charT , traits > & os ) 
{ 
os . put ( charT ( 0 ) ) ; 
return os ; 
} 

template < class charT , class traits > 
inline basic_ostream < charT , traits > & 
flush ( basic_ostream < charT , traits > & os ) 
{ 
os . flush ( ) ; 
return os ; 
} 


} 
#39 "/opt/SUNWspro/SC5.0/include/CC/./istream"
namespace std { 


extern istream cin ; 


extern wistream wcin ; 


template < class charT , class 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_istream < charT , traits > istream_type ; 
typedef basic_ios < charT , traits > ios_type ; 
typedef basic_streambuf < charT , traits > streambuf_type ; 

basic_istream ( basic_streambuf < charT , traits > * sb ) ; 

basic_istream ( EmptyCtor ) : basic_ios < charT , traits > ( 1 ) { } 
virtual ~ basic_istream ( ) ; 

class sentry 
{ 
public : 

inline sentry ( basic_istream < charT , traits > & stream , 
bool noskipws = 0 ) 
: __stream ( stream ) 
{ 

if ( stream . rdbuf ( ) ) 
__guard = new _RWSTDGuard ( stream . rdbuf ( ) -> buffer_mutex_ ) ; 

try { 



if ( ! ( stream . good ( ) ) ) 
{ 
stream . setstate ( ios_base :: failbit ) ; 
__ok = false ; 
} 
else 
{ 
if ( stream . tie ( ) ) 
stream . tie ( ) -> flush ( ) ; 

if ( ! noskipws && ( stream . flags ( ) & ios_base :: skipws ) ) 
{ 
int_type c ; 




const ctype < charT > & ct = use_facet ( stream . getloc ( ) , ( ctype < charT > * ) 0 ) ; 


while ( ( c = stream . rdbuf ( ) -> sgetc ( ) ) , 
( ! traits :: eq_int_type ( c , traits :: eof ( ) ) && ct . is ( ct . space , c ) ) ) 
{ 
stream . rdbuf ( ) -> snextc ( ) ; 
} 

if ( traits :: eq_int_type ( c , traits :: eof ( ) ) ) 
{ 
stream . setstate ( ios_base :: eofbit ) ; 
} 
} 

if ( ! ( stream . good ( ) ) ) 
{ 
stream . setstate ( ios_base :: failbit ) ; 
__ok = false ; 
} 
else 
__ok = true ; 
} 

} catch ( ... ) 
{ 
if ( __stream . rdbuf ( ) ) 
delete __guard ; 
throw ; 
} 

} 

~ sentry ( ) { 

if ( __stream . rdbuf ( ) ) 
delete __guard ; 

} 
operator bool ( ) { return __ok ; } 

private : 
basic_istream < charT , traits > & __stream ; 
bool __ok ; 

_RWSTDGuard * __guard ; 


} ; 

istream_type & operator >> ( istream_type & ( * pf ) ( istream_type & ) ) ; 
istream_type & operator >> ( ios_base & ( * pf ) ( ios_base & ) ) ; 
istream_type & operator >> ( ios_type & ( * pf ) ( ios_type & ) ) ; 


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 >> ( float & f ) ; 
istream_type & operator >> ( double & f ) ; 
istream_type & operator >> ( long double & f ) ; 

istream_type & operator >> ( long long & n ) ; 
istream_type & operator >> ( unsigned long long & n ) ; 

istream_type & operator >> ( void * & p ) ; 
istream_type & operator >> ( streambuf_type & sb ) ; 
istream_type & operator >> ( streambuf_type * sb ) ; 

int_type get ( ) 
{ 
ios_base :: iostate err = 0 ; 


try { 

typename basic_istream < charT , traits > :: sentry ipfx ( * this , 1 ) ; 
__chcount = 0 ; 

if ( ipfx ) 
{ 
int_type c = this -> rdbuf ( ) -> sbumpc ( ) ; 

if ( traits :: eq_int_type ( c , traits :: eof ( ) ) ) 
{ 
err = ios_base :: eofbit | ios_base :: failbit ; 
} 
else 
{ 
__chcount = 1 ; 
return c ; 
} 
} 


} 
catch ( ... ) 
{ 
bool flag = false ; 
try { 
this -> setstate ( ios_base :: badbit ) ; 
} 
catch ( ios_base :: failure ) { flag = true ; } 
if ( flag ) throw ; 
} 


if ( err ) this -> setstate ( err ) ; 

return traits :: eof ( ) ; 
} 


istream_type & get ( char_type * s , streamsize n , char_type delim ) ; 
istream_type & get ( char_type * s , streamsize n ) 
{ return get ( s , n , this -> widen ( '\n' ) ) ; } 

istream_type & get ( char_type & c ) ; 

istream_type & get ( streambuf_type & sb , char_type delim ) ; 
istream_type & get ( streambuf_type & sb ) 
{ return get ( sb , this -> widen ( '\n' ) ) ; } 

istream_type & getline ( char_type * s , streamsize n , char_type delim ) ; 
istream_type & getline ( char_type * s , streamsize n ) 
{ return getline ( s , n , this -> widen ( '\n' ) ) ; } 

istream_type & ignore ( streamsize n = 1 , int_type delim = traits :: eof ( ) ) ; 

istream_type & read ( char_type * s , streamsize n ) ; 

streamsize readsome ( char_type * s , streamsize n ) ; 

int_type peek ( ) ; 

pos_type tellg ( ) ; 




istream_type & seekg ( pos_type pos ) 
{ 
ios_base :: iostate err = 0 ; 


try { 

if ( this -> rdstate ( ) & ios_base :: eofbit ) 
clear ( this -> rdstate ( ) & ~ ios_base :: eofbit ) ; 


if ( this -> rdbuf ( ) ) { 
_RWSTDGuard guard ( this -> rdbuf ( ) -> buffer_mutex_ ) ; 



if ( ! this -> fail ( ) ) 
this -> rdbuf ( ) -> pubseekpos ( pos , ios_base :: in ) ; 


} 



} 



catch ( ... ) 
{ 
bool flag = false ; 
try { 
this -> setstate ( ios_base :: badbit ) ; 
} 
catch ( ios_base :: failure ) { flag = true ; } 
if ( flag ) throw ; 
} 


return * this ; 
} 

istream_type & seekg ( off_type off , ios_base :: seekdir dir ) 
{ 
ios_base :: iostate err = 0 ; 


try { 



if ( this -> rdbuf ( ) ) { 
_RWSTDGuard guard ( this -> rdbuf ( ) -> buffer_mutex_ ) ; 

if ( ! this -> fail ( ) ) 
{ 
this -> rdbuf ( ) -> pubseekoff ( off , dir , ios_base :: in ) ; 
} 


} 



} 



catch ( ... ) 
{ 
bool flag = false ; 
try { 
this -> setstate ( ios_base :: badbit ) ; 
} 
catch ( ios_base :: failure ) { flag = true ; } 
if ( flag ) throw ; 
} 


return * this ; 
} 

int sync ( ) ; 

istream_type & putback ( char_type c ) ; 

istream_type & unget ( ) ; 

streamsize gcount ( ) const ; 


_RWSTDGuard * istream_sentry_guard ; 


protected : 
basic_istream ( ) ; 

private : 
streamsize __chcount ; 
} ; 
#355
template < class charT , class traits > 
class basic_iostream : public basic_istream < charT , traits > , 
public basic_ostream < charT , traits > 
{ 
public : 
basic_iostream ( basic_streambuf < charT , traits > * sb ) ; 
virtual ~ basic_iostream ( ) ; 

protected : 
basic_iostream ( ) ; 
} ; 
#384
template < class T , class charT , class traits , class Distance > 



class istream_iterator 
: public iterator < input_iterator_tag , T , Distance , const T * , const T & > 
{ 





friend inline bool operator == ( 
const istream_iterator < T , charT , traits , Distance > & x , 
const istream_iterator < T , charT , traits , Distance > & y ) ; 

public : 
typedef charT char_type ; 
typedef traits traits_type ; 
typedef basic_istream < charT , traits > istream_type ; 
typedef T value_type ; 

istream_iterator ( ) : stream ( & cin ) , end_marker ( false ) { } 
istream_iterator ( basic_istream < charT , traits > & s ) : stream ( & s ) { read ( ) ; } 
istream_iterator ( const istream_iterator < T , charT , traits , Distance > & x ) 
: stream ( x . stream ) , value ( x . value ) , end_marker ( x . end_marker ) 
{ ; } 
const T & operator * ( ) const { return value ; } 

const T * operator -> ( ) const { return & value ; } 

istream_iterator < T , charT , traits , Distance > & operator ++ ( ) 
{ 
read ( ) ; 
return * this ; 
} 
istream_iterator < T , charT , traits , Distance > operator ++ ( int ) 
{ 
istream_iterator < T , charT , traits , Distance > tmp = * this ; 
read ( ) ; 
return tmp ; 
} 

protected : 
basic_istream < charT , traits > * stream ; 
T value ; 
bool end_marker ; 

void read ( ) 
{ 
end_marker = ( * stream ) ? true : false ; 
if ( end_marker ) * stream >> value ; 
end_marker = ( * stream ) ? true : false ; 
} 

} ; 

template < class T , class charT , class traits , class Distance > 
inline bool operator == 
( const istream_iterator < T , charT , traits , Distance > & x , 
const istream_iterator < T , charT , traits , Distance > & y ) 
{ 
return x . stream == y . stream && x . end_marker == y . end_marker || 
x . end_marker == false && y . end_marker == false ; 
} 


template < class T , class charT , class traits , class Distance > 
inline bool operator != 
( const istream_iterator < T , charT , traits , Distance > & x , 
const istream_iterator < T , charT , traits , Distance > & y ) 
{ 
return ! ( x == y ) ; 
} 


template < class charT , class traits > 
basic_istream < charT , traits > & 
ws ( basic_istream < charT , traits > & is ) ; 


typedef basic_istream < char > istream ; 
#472
typedef basic_istream < wchar_t > wistream ; 
#479
typedef basic_iostream < char > iostream ; 
#486
typedef basic_iostream < wchar_t > wiostream ; 
#495
template < class charT , class traits > 
basic_istream < charT , traits > & 
operator >> ( basic_istream < charT , traits > & , charT & ) ; 

template < class charT , class traits > 
basic_istream < charT , traits > & 
operator >> ( basic_istream < charT , traits > & , charT * ) ; 





template < class traits > 
basic_istream < char , traits > & 
operator >> ( basic_istream < char , traits > & , unsigned char & ) ; 

template < class traits > 
basic_istream < char , traits > & 
operator >> ( basic_istream < char , traits > & , signed char & ) ; 

template < class traits > 
basic_istream < char , traits > & 
operator >> ( basic_istream < char , traits > & , unsigned char * ) ; 

template < class traits > 
basic_istream < char , traits > & 
operator >> ( basic_istream < char , traits > & , signed char * ) ; 





} 
namespace __rwstd { 


template < class streamT , class stringT , class traits > 
streamT & rw_extract_string ( streamT & is , stringT & s , traits ) ; 


} 
namespace std { 


template < class charT , class traits , class Allocator > 
inline basic_istream < charT , traits > & 
operator >> ( basic_istream < charT , traits > & is , 
basic_string < charT , traits , Allocator > & s ) 
{ 
return __rwstd :: rw_extract_string ( is , s , traits ( ) ) ; 
} 

template < class charT , class traits , class Allocator > 
basic_istream < charT , traits > & 
getline ( basic_istream < charT , traits > & , 
basic_string < charT , traits , Allocator > & , 
charT delim ) ; 

template < class charT , class traits , class Allocator > 
inline basic_istream < charT , traits > & 
getline ( basic_istream < charT , traits > & is , 
basic_string < charT , traits , Allocator > & str ) 
{ return getline ( is , str , is . widen ( '\n' ) ) ; } 



} 
#4 "/opt/SUNWspro/SC5.0/include/CC/iostream.h"
using std :: istream ; 
using std :: cin ; 


using std :: ostream ; 
using std :: cout ; 
using std :: cerr ; 
using std :: clog ; 

using std :: ios ; 
using std :: iostream ; 
using std :: streambuf ; 



using std :: endl ; 
using std :: ends ; 
using std :: flush ; 
using std :: streamsize ; 
using std :: unitbuf ; 
using std :: nounitbuf ; 
using std :: boolalpha ; 
using std :: noboolalpha ; 
using std :: showbase ; 
using std :: noshowbase ; 
using std :: showpoint ; 
using std :: noshowpoint ; 
using std :: showpos ; 
using std :: noshowpos ; 
using std :: skipws ; 
using std :: noskipws ; 
using std :: uppercase ; 
using std :: nouppercase ; 
using std :: internal ; 
using std :: left ; 
using std :: right ; 
using std :: dec ; 
using std :: hex ; 
using std :: oct ; 
using std :: fixed ; 
using std :: scientific ; 
#4
using std :: istream ; 
using std :: cin ; 


using std :: ostream ; 
using std :: cout ; 
using std :: cerr ; 
using std :: clog ; 

using std :: ios ; 
using std :: iostream ; 
using std :: streambuf ; 



using std :: endl ; 
using std :: ends ; 
using std :: flush ; 
using std :: streamsize ; 
using std :: unitbuf ; 
using std :: nounitbuf ; 
using std :: boolalpha ; 
using std :: noboolalpha ; 
using std :: showbase ; 
using std :: noshowbase ; 
using std :: showpoint ; 
using std :: noshowpoint ; 
using std :: showpos ; 
using std :: noshowpos ; 
using std :: skipws ; 
using std :: noskipws ; 
using std :: uppercase ; 
using std :: nouppercase ; 
using std :: internal ; 
using std :: left ; 
using std :: right ; 
using std :: dec ; 
using std :: hex ; 
using std :: oct ; 
using std :: fixed ; 
using std :: scientific ; 
#20 "vector.h"
template < class T > 

class Vector 
{ 
public : 

T * v ; 
int l , h ; 

Vector ( int l1 , int h1 ) { allocate ( l1 , h1 ) ; } 
Vector ( int h1 ) { allocate ( 1 , h1 ) ; } 
Vector ( ) { allocate ( 1 , 1 ) ; } 
virtual ~ Vector ( ) ; 

int low ( ) const { return l ; } 
int high ( ) const { return h ; } 

virtual T Top ( ) const { return v [ h ] ; } 

int memSpace ( ) const ; 
int size ( ) const ; 
virtual void resize ( int newh ) ; 
virtual void resize ( int newl , int newh ) ; 
void extendAndCopy ( int newh ) ; 

T & operator [ ] ( int i ) 
{ 
if ( 0 ) checkBounds ( i ) ; 
return v [ i ] ; 
} 

const T & operator [ ] ( int i ) const 
{ 
if ( 0 ) checkBounds ( i ) ; 
return v [ i ] ; 
} 



void print ( ) const ; 

protected : 

void allocate ( int l1 , int h1 ) ; 
void checkBounds ( int i ) const ; 

void notImplemented ( const char * s ) const ; 

private : 

Vector ( Vector < T > & vec ) ; 
Vector < T > & operator = ( Vector < T > & vec ) ; 
Vector < T > & operator = ( T a ) ; 
} ; 
#10 "stack.h"
const int DefaultSize = 25 ; 


template < class T > 

class Stack : public Vector < T > 
{ 
public : 

int top ; 

Stack ( int l1 , int top1 , int h1 ) ; 
Stack ( int l1 , int top1 ) ; 
Stack ( int top1 ) ; 
Stack ( ) ; 
virtual ~ Stack ( ) { } 

void push ( const T a ) ; 
T pop ( ) ; 
T Prev ( ) const ; 

virtual T Top ( ) const ; 

int empty ( ) const { return h < l ; } 

virtual void resize ( int newTop ) ; 
virtual void resize ( int newl , int newTop ) ; 
virtual void resize ( int newl , int newTop , int newh ) ; 

private : 
void extend ( ) ; 

Stack ( Stack < T > & st ) ; 


} ; 
#12 "dict.h"
const DefaultDictSize = 25 ; 


class Dict 
{ 
public : 

Stack < char * > key ; 
Stack < char * > val ; 

Dict ( ) ; 
Dict ( int h1 ) ; 
~ Dict ( ) ; 

void push ( const char * const name , const char * const value ) ; 
int inDict ( const char * const akey ) ; 
void changeValue ( const char * const s , const char * const value ) ; 

int getVal ( const char * const akey , char * value ) ; 
int getVal ( const char * const akey , int * value ) ; 
int getVal ( const char * const akey , double * value ) ; 
int getVal ( const char * const akey , float * value ) ; 

int getKeyIndex ( const char * const akey , int * index ) ; 

void ambiguityCheck ( ) ; 
friend ostream & operator << ( ostream & s , Dict & dict ) ; 
} ; 
#19 "dict.cc"
Dict :: Dict ( ) : key ( 1 , DefaultDictSize ) , val ( 1 , DefaultDictSize ) { } 
Dict :: Dict ( int h ) : key ( 1 , h ) , val ( 1 , h ) { } 

Dict :: ~ Dict ( ) 
{ 
for ( int i = key . l ; i <= key . h ; ++ i ) { delete key [ i ] ; delete val [ i ] ; } 
} 


void Dict :: push ( const char * const s , const char * const value ) 
{ 
char * newkey = new char [ strlen ( s ) + 1 ] ; 
char * newval = new char [ strlen ( value ) + 1 ] ; 
strcpy ( newkey , s ) ; 
strcpy ( newval , value ) ; 
key . push ( newkey ) ; 
val . push ( newval ) ; 
} 


void Dict :: changeValue ( const char * const s , const char * const value ) 
{ 
int index ; 

getKeyIndex ( s , & index ) ; 

cout << "\n  Command overwritten:  " 
<< key . v [ index ] << " = " << val . v [ index ] << "\n\t\t\t" 
<< s << " = " << value << "\t <-- used value" ; 

delete key [ index ] ; 
delete val [ index ] ; 

char * newkey = new char [ strlen ( s ) + 1 ] ; 
char * newval = new char [ strlen ( value ) + 1 ] ; 
strcpy ( newkey , s ) ; 
strcpy ( newval , value ) ; 
key [ index ] = newkey ; 
val [ index ] = newval ; 
} 


int Dict :: inDict ( const char * const akey ) 
{ 
int i , n , n1 , n2 ; 

n1 = strlen ( akey ) ; 

for ( i = key . h ; i >= key . l ; -- i ) 
{ 
n2 = strlen ( key [ i ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( akey , key [ i ] , n ) ) return 1 ; 
} 
return 0 ; 
} 


int Dict :: getVal ( const char * const akey , char * xval ) 
{ 
int i , n , n1 , n2 ; 

n1 = strlen ( akey ) ; 
for ( i = key . h ; i >= key . l ; -- i ) 
{ 
n2 = strlen ( key [ i ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( akey , key [ i ] , n ) ) 
{ 
strcpy ( xval , val [ i ] ) ; 
return 1 ; 
} 
} 
return 0 ; 
} 


int Dict :: getVal ( const char * const akey , int * xval ) 
{ 
int i , n , n1 , n2 ; 

n1 = strlen ( akey ) ; 
for ( i = key . h ; i >= key . l ; -- i ) 
{ 
n2 = strlen ( key [ i ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( akey , key [ i ] , n ) ) 
{ 
* xval = atoi ( val [ i ] ) ; 
return 1 ; 
} 
} 
return 0 ; 
} 


int Dict :: getVal ( const char * const akey , double * xval ) 
{ 
int i , n , n1 , n2 ; 

n1 = strlen ( akey ) ; 
for ( i = key . h ; i >= key . l ; -- i ) 
{ 
n2 = strlen ( key [ i ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( akey , key [ i ] , n ) ) { * xval = atof ( val [ i ] ) ; return 1 ; } 
} 
return 0 ; 
} 


int Dict :: getVal ( const char * const akey , float * xval ) 
{ 
int i , n , n1 , n2 ; 

n1 = strlen ( akey ) ; 
for ( i = key . h ; i >= key . l ; -- i ) 
{ 
n2 = strlen ( key [ i ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( akey , key [ i ] , n ) ) { * xval = atof ( val [ i ] ) ; return 1 ; } 
} 
return 0 ; 
} 


int Dict :: getKeyIndex ( const char * const akey , int * index ) 
{ 
int i , n , n1 , n2 ; 

n1 = strlen ( akey ) ; 

for ( i = key . h ; i >= key . l ; -- i ) 
{ 
n2 = strlen ( key [ i ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( akey , key [ i ] , n ) ) { * index = i ; return 1 ; } 
} 
return 0 ; 
} 


void Dict :: ambiguityCheck ( ) 
{ 
int i , k , n1 , n2 , n ; 

for ( i = 1 ; i < key . h ; ++ i ) 
{ 
n1 = strlen ( key . v [ i ] ) ; 

for ( k = 1 ; k <= key . h ; ++ k ) 
{ 
if ( k == i ) continue ; 

n2 = strlen ( key . v [ k ] ) ; 
n = ( ( n1 ) < ( n2 ) ) ? ( n1 ) : ( n2 ) ; 
if ( ! strncmp ( key . v [ k ] , key . v [ i ] , n ) ) 
{ 
cout << "\n\n*** Dict: ambiguous keys: '" << key . v [ k ] 
<< "' '" << key . v [ i ] << "'\n" ; 
cout . flush ( ) ; abort ( ) ; 
} 
} 
} 
cout << "\n" ; 
} 
#194
ostream & operator << ( ostream & os , Dict & dict ) 
{ 

for ( int i = dict . key . l ; i <= dict . key . h ; ++ i ) 
{ 
os << ( dict . key ) . v [ i ] << " \t" ; 
os << ( dict . val ) . v [ i ] << "\n" ; 
} 
return os ; 
}