#line 1 "/net/cci/rwgk/dist/boost/libs/python/src/converter/arg_to_python_base.cpp"






#line 1 "/net/cci/rwgk/dist/boost/boost/python/converter/arg_to_python_base.hpp"





#line 1 "/net/cci/rwgk/dist/boost/boost/python/converter/to_python_function_type.hpp"





#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits_cname_impl"










 






#line 58 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits_cname_impl"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 32 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"




 



 






 






 

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 26 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyconfig.h"
 
 



 

 


 

 


 
 

 
 

 


 


 


 



 
 

 
 

 
 

 
 

 
 


 
 

 
 

 


 
 

 


 


 
 

 
 


 
 


 
 


 
 


 
 

 
 

 
 

 
 

 
 

 


 
 


 
 

 
 

 


 
 

 


 


 


 


 


 


 
 

 
 





 
 

 


 


 
 

 
 

 
 


 


 
 



 
 

 


 


 


 


 


 
 

 


 
 

 
 

 


 


 
 



 
 

 


 


 


 


 



 


 
 

 
 

 
 


 
 

 










  
 



 
 

 
 


 
 

 
 





  
 

 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 
 

 


 


 


 


 


 


 
 

 


 


 


 


 


 


 


 


 
 

 


 


 


 
 

 


 


 


 


 


 


 


 
 

 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 


 


 


 


 
 

 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 


 
 

 


 


 


 


 


 
 

 
 

 


 


 


 
 

 


 


 
 

 


 


 
 

 


 
 

 
 

 


 


 


 


 


 


 


 
 

 
 

 


 


 
 

 
 

 


 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 
 

 
 

 
 

#line 763 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyconfig.h"

 




#line 27 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 30 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"


 
#line 39 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"

#line 43 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"

extern "C" {
namespace std {

typedef unsigned long   size_t;




typedef long    fpos_t;


}    
}    

#line 72 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"







 
#line 89 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"









extern "C" {

#line 143 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"
namespace std {
typedef struct {
	int	_cnt;
	unsigned int	_flag2;
	unsigned char	*_ptr;
	unsigned char	*_base;
	int	_bufsiz;
	short	_flag;
	short	_file;




	char	*__newbase;
	void	*_lock;			 
	unsigned char	*_bufendp;
} FILE;
}    




#line 173 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"
extern std::FILE	_iob[];





}    


extern "C" {
namespace std {

extern size_t	fread (void *, size_t, size_t, FILE *);
extern size_t	fwrite (const void *, size_t, size_t, FILE *);

extern int 	ferror (FILE *);
extern int 	feof (FILE *);
extern void 	clearerr (FILE *);
extern int 	putchar (int);
extern int 	getchar (void);
extern int 	putc (int, FILE *);
extern int 	getc (FILE *);
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 *, ...);

#line 218 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"

extern int 	fgetc (FILE *);
extern char 	*fgets (char *, int, FILE *);
extern int 	fputc (int, FILE *);
extern int 	fputs (const char *, FILE *);
extern char 	*gets (char *);
extern int 	puts (const char *);
extern int	ungetc (int, 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 	perror (const char *);

}   
}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_ansi_impl"










 

using std::FILE;
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::fpos_t;
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::size_t;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio.h"
#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio.h"






#line 46 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 45 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_cname_impl"







namespace std {
extern "C" {

typedef unsigned long   size_t;

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

}   

 
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_ovrld_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_ovrld_impl"










 


 

extern "C++" {

    inline char *strchr (char * _s, int _c) {
        return (char*)strchr((const char*)_s, _c);
    }
    inline char *strpbrk (char * _s1, const char * _s2) {
        return (char*)strpbrk((const char*)_s1, _s2);
    }
    inline char	*strrchr (char * _s, int _c) {
        return (char*)strrchr((const char*)_s, _c);
    }
    inline char *strstr (char * _s1, const char * _s2) {
        return (char*)strstr((const char*)_s1, _s2);
    }
    inline void *memchr (void * _s, int _c, size_t _n) {
        return (void*)memchr((const void*)_s, _c, _n);
    }

}   
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 58 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_cname_impl"

}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string_ansi_impl"










 

using std::memchr;
using std::memcmp;
using std::memcpy;
using std::memmove;
using std::memset;
using std::size_t;
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;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string.h"
#line 31 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string.h"

#line 39 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/string.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 50 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/errno.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/errno.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/errno_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/errno_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/errno_cname_impl"
extern "C" {




extern int *_errno (void);


}





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/errno.h"







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 51 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_cname_impl"
















namespace std {
extern "C" {

typedef unsigned long   size_t;

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

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


 




extern void	abort (void);
extern int	atexit (void (*)(void));
extern void	exit (int);
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 long int	labs (long int );
extern struct div_t	div (int , int );
extern struct ldiv_t 	ldiv (long int , long int );



 
extern int	mblen (const char *, size_t);
extern size_t	mbstowcs (wchar_t *, const char *, size_t);
extern int	mbtowc (wchar_t *, const char *, size_t);
extern size_t	wcstombs (char *, const wchar_t *, size_t);
extern int	wctomb (char *, wchar_t);

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 );

}   

 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_ovrld_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_ovrld_impl"










 


 

extern "C++" {

   inline long     abs (long _n) { return labs(_n); }
   inline ldiv_t   div (long _n, long _d) { return ldiv(_n, _d); }

}   
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 93 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_cname_impl"

}   


#line 105 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_cname_impl"

extern "C" {
extern int __getmbcurmax (void);
}



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_ansi_impl"










 

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::div_t;
using std::exit;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::ldiv_t;
using std::malloc;
using std::mblen;
using std::mbstowcs;
using std::mbtowc;
using std::qsort;
using std::rand;
using std::realloc;
using std::size_t;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;
using std::wcstombs;
using std::wctomb;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"
#line 31 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"

#line 39 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 53 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/include/unistd.h"


















 


 


  



 


 

















 




extern "C" {


#line 1 "/usr/include/standards.h"


















 


 


  



 


 












 














                                                                    









 

#line 80 "/usr/include/standards.h"





  





#line 101 "/usr/include/standards.h"

 





  

#line 116 "/usr/include/standards.h"



#line 129 "/usr/include/standards.h"

 














 

#line 165 "/usr/include/standards.h"

 










 

#line 191 "/usr/include/standards.h"
 





 


 

 
#line 209 "/usr/include/standards.h"





 
#line 230 "/usr/include/standards.h"

 




 
#line 249 "/usr/include/standards.h"

#line 258 "/usr/include/standards.h"







 












 
 
 
 






 
 






 
 






 
 
#line 314 "/usr/include/standards.h"

 
 






#line 334 "/usr/include/standards.h"

#line 59 "/usr/include/unistd.h"




#line 1 "/usr/include/sys/types.h"


















 


 


  



 


 













 






 





extern "C" {









 



typedef signed long     ptrdiff_t;


#line 92 "/usr/include/sys/types.h"



typedef unsigned int wctype_t;




typedef long            fpos_t;


 
#line 1 "/usr/include/time_t.h"


















 


 


 




extern "C" {



typedef int             time_t;

#line 55 "/usr/include/time_t.h"


}
#line 105 "/usr/include/sys/types.h"



typedef int             clock_t;




typedef unsigned long   size_t;








typedef long                    ssize_t;  




 
typedef	unsigned char	uchar_t;
typedef	unsigned short	ushort_t;
typedef	unsigned int	uint_t;
typedef unsigned long	ulong_t;
typedef	volatile unsigned char	vuchar_t;
typedef	volatile unsigned short	vushort_t;
typedef	volatile unsigned int	vuint_t;
typedef volatile unsigned long	vulong_t;




typedef	struct	{ long r[1]; } *physadr_t;



 
typedef	struct	label_t	{
	long	val[10];
} label_t;


#line 162 "/usr/include/sys/types.h"

#line 173 "/usr/include/sys/types.h"


#line 185 "/usr/include/sys/types.h"

#line 192 "/usr/include/sys/types.h"

#line 199 "/usr/include/sys/types.h"

#line 206 "/usr/include/sys/types.h"

#line 213 "/usr/include/sys/types.h"



typedef int		level_t;
typedef	int		daddr_t;	 
typedef long		daddr64_t;	 
typedef	char *		caddr_t;	 
typedef long *		qaddr_t;         
typedef char *          addr_t;
typedef	uint_t		ino_t;		 
typedef short		cnt_t;
typedef int		dev_t;		 
typedef	int		chan_t;		 






typedef long    off_t;			 


typedef long t_scalar_t;
typedef unsigned long t_uscalar_t;

#line 249 "/usr/include/sys/types.h"

typedef unsigned long	rlim_t;		 
typedef	int		paddr_t;
typedef	ushort_t	nlink_t;



typedef int    		key_t;		 




typedef	uint_t		mode_t;		 







typedef uint_t		uid_t;		 





typedef uint_t		gid_t;		 




typedef	void *		mid_t;		 




typedef	int		pid_t;		 

typedef union cpid {			 
	struct {
		unsigned int pid:19;	 
		unsigned int nodeid:8;	 
		unsigned int seqnum:4;	 
		unsigned int signbit:1;	 
	} cluster_fields;
	pid_t ipid;			 
} cpid_t;






typedef char		slab_t[12];	 

typedef ulong_t		shmatt_t;	 
typedef ulong_t		msgqnum_t;	 
typedef ulong_t		msglen_t;	 



        typedef unsigned int wint_t;          


 





typedef unsigned long 	sigset_t;



 


#line 335 "/usr/include/sys/types.h"

typedef struct __pthread_attr_t {
    long		__valid;
    char*		__name;
    unsigned long	__arg;
    unsigned long	__reserved[19];
} pthread_attr_t;

typedef struct __pthread_mutexattr_t {
    long		__valid;
    unsigned long	__reserved[15];
} pthread_mutexattr_t;

typedef struct __pthread_condattr_t {
    long		__valid;
    unsigned long	__reserved[13];
} pthread_condattr_t;

typedef struct __pthread_rwlockattr_t {
    long		__valid;
    unsigned long	__reserved[15];
} pthread_rwlockattr_t;

#line 365 "/usr/include/sys/types.h"



















 

typedef struct __pthread_t {
    void*		__reserved1;	 
    void*		__reserved2;	 
    unsigned short	__size;	  	 
    unsigned char	__version;	 
    unsigned char	__reserved3;	 
    unsigned char	__external;	 
    unsigned char	__reserved4[2];	 
    unsigned char	__creator;	 
    unsigned long	__sequence;	 
    unsigned long	__reserved5[2];	 
    void*		__per_kt_area;	 
    void*		__stack_base;	 
    void*		__stack_reserve;	 
    void*		__stack_yellow;	 
    void*		__stack_guard;	 
    unsigned long	__stack_size;	 
    void**		__tsd_values;	 
    unsigned long	__tsd_count;	 
    unsigned int	__reserved6;	 
    unsigned int	__reserved7;	 
    unsigned int	__thread_flags;	 
    int			__thd_errno;	 
    void*		__stack_hiwater;  
} *pthread_t, pthreadTeb_t;

typedef struct __pthread_mutex_t {
    unsigned int	__lock;
    unsigned int	__valid;
    char*		__name;
    unsigned int	__arg;
    unsigned int	__depth;
    unsigned long	__sequence;
    unsigned long	__owner;
    void*		__block;
} pthread_mutex_t;

typedef struct __pthread_cond_t {
    unsigned int	__state;
    unsigned int	__valid;
    char*		__name;
    unsigned int	__arg;
    unsigned int	__reserved1;
    unsigned long	__sequence;
    void*		__block;
} pthread_cond_t;

typedef struct __pthread_rwlock_t {
    unsigned int	__valid;
    unsigned int	__flags;
    char*		__name;
    unsigned int	__arg;
    unsigned int	__readers;
    unsigned int	__rwaits;
    unsigned int	__wwaits;
    unsigned long	__sequence;
    unsigned long	__wrid;
    void*		__block;
    unsigned long	__reserved1;
} pthread_rwlock_t;

typedef unsigned int	pthread_key_t;

typedef struct __pthread_once_t {
    long	__state;
    long	__reserved[10];
} pthread_once_t;








 
typedef long            timer_t;         


#line 471 "/usr/include/sys/types.h"

















typedef void (*sig_t) (int,void (*)(int));






typedef	unsigned int cpuid_t;
enum	{ CPU_NONE=(-1) };	 










 
typedef pid_t		id_t;		 
					 
					 
					 
					 
typedef unsigned int	useconds_t;	 







 
typedef uint_t	major_t;       
typedef uint_t	minor_t;       
typedef uint_t	devs_t;        
typedef uint_t	unit_t;        



 






 
#line 544 "/usr/include/sys/types.h"

#line 1 "/usr/include/mach/machine/vm_types.h"


















 


 


  


















 



 


 






 

 






typedef	unsigned long	vm_offset_t;
typedef	unsigned long	vm_size_t;


#line 546 "/usr/include/sys/types.h"



 
typedef	uchar_t		uchar;
typedef	ushort_t	ushort;
typedef	uint_t		uint;
typedef ulong_t		ulong;

typedef	physadr_t	physadr;

 
typedef	uchar_t		u_char;
typedef	ushort_t 	u_short;
typedef	uint_t		u_int;
typedef	ulong_t		u_long;
typedef	vuchar_t	vu_char;
typedef	vushort_t 	vu_short;
typedef	vuint_t		vu_int;
typedef	vulong_t	vu_long;




typedef struct  _quad { int val[2]; } quad;


typedef	long	swblk_t;
typedef u_long	fixpt_t;

#line 1 "/usr/include/sys/select.h"


















 


 


  

 



 




 


 




extern "C" {




#line 1 "/usr/include/sys/types.h"


















 


 


  



 


 













 






 

#line 51 "/usr/include/sys/select.h"


#line 139 "/usr/include/sys/select.h"









 



#line 163 "/usr/include/sys/select.h"

typedef int	fd_mask;



 


















typedef	struct fd_set {
	fd_mask	fds_bits[((((unsigned)4096)+(((sizeof(fd_mask) * 8))-1))/((sizeof(fd_mask) * 8)))];
} fd_set;





#line 220 "/usr/include/sys/select.h"













 
#line 240 "/usr/include/sys/select.h"
extern void  bzero (void *, size_t);






struct timeval;
int select (int, fd_set *, fd_set *, fd_set *, struct timeval *);





}
#line 577 "/usr/include/sys/types.h"



 

typedef unsigned char sa_family_t;

 
typedef	unsigned int	in_addr_t;
 
typedef	unsigned short	in_port_t;










}


#line 65 "/usr/include/unistd.h"
#line 1 "/usr/include/sys/access.h"


















 


 


  

 



 





  












 


 









 




 


















#line 66 "/usr/include/unistd.h"






 


 

#line 1 "/usr/include/sys/seek.h"


















 


 


 



 


 




 










#line 78 "/usr/include/unistd.h"
#line 1 "/usr/include/getopt.h"


















 


 


 



  


 







extern "C"
{

extern int getopt (int, char * const [], const char *);

}


extern char *optarg;
extern int optind;
extern int optopt;
extern int opterr;

#line 79 "/usr/include/unistd.h"

 

extern char **environ;           
 
struct sockaddr_in;








extern ssize_t  pread (int, void *, size_t, off_t);
extern ssize_t  pwrite (int , const void *, size_t, off_t);


extern ssize_t	read (int, void *, size_t);
extern ssize_t	write (int , const void *, size_t); 


extern int access (const char *, int );
extern unsigned int alarm (unsigned int );
extern int chdir (const char *);
extern int chown (const char *, uid_t , gid_t );
extern int chroot (const char *);
extern int close (int );
extern size_t confstr (int, char *, size_t);

#line 124 "/usr/include/unistd.h"

extern int dup (int );
extern int dup2 (int , int );

 
extern int execl (const char *, const char *, ...);
extern int execv (const char *, char *const[]);
extern int execle (const char *, const char *, ...); 
extern int execve (const char *, char *const[], char *const[]);
extern int execlp (const char *, const char *, ...); 
extern int execvp (const char *, char *const[]);
 

extern void _exit (int );
extern pid_t fork (void);
extern long fpathconf (int , int );
extern int fsync (int);

extern int fdatasync (int);

extern char *getcwd (char *, size_t );
extern gid_t getegid (void);
extern uid_t geteuid (void);
extern gid_t getgid (void);


 
extern int getgroups (int , gid_t []);

extern char *getlogin (void);
extern pid_t getpgrp (void);
extern pid_t getpid (void);
extern pid_t getppid (void);
extern uid_t getuid (void);
extern int isatty (int );
extern int link (const char *, const char *);
extern off_t lseek (int , off_t , int );
extern long pathconf (const char *, int );
extern int pause (void);


 

#line 174 "/usr/include/unistd.h"

extern int pipe (int []);







extern int rmdir (const char *);
extern int setgid (gid_t );
extern int setpgid (pid_t , pid_t );
extern pid_t setsid (void);
extern int setuid (uid_t );
extern unsigned int sleep (unsigned int );


extern int usleep (useconds_t );	 
#line 199 "/usr/include/unistd.h"

extern long sysconf (int );
extern pid_t tcgetpgrp (int );
extern int tcsetpgrp (int , pid_t );
extern char *ttyname (int );
extern int unlink (const char *);

extern void swab (const void *, void *, ssize_t);


 


#line 220 "/usr/include/unistd.h"
extern int _Pgetlogin_r (char *, size_t);	 
extern int _Pttyname_r (int, char *, size_t);	 






extern ssize_t pread (int, void *, size_t, off_t);
extern ssize_t pwrite (int, const void *, size_t, off_t);
extern int pthread_atfork (void (*)(void), void (*)(void), void (*)(void));

#line 242 "/usr/include/unistd.h"










 























#line 282 "/usr/include/unistd.h"

#line 289 "/usr/include/unistd.h"












 

#line 316 "/usr/include/unistd.h"




 




 
#line 353 "/usr/include/unistd.h"



 






 
#line 372 "/usr/include/unistd.h"



 









 
#line 403 "/usr/include/unistd.h"






 



#line 420 "/usr/include/unistd.h"

#line 437 "/usr/include/unistd.h"



 

#line 476 "/usr/include/unistd.h"



#line 485 "/usr/include/unistd.h"



















 

#line 522 "/usr/include/unistd.h"


 

































 
#line 565 "/usr/include/unistd.h"
 


















extern int  fchown (int, uid_t, gid_t);
extern int  ftruncate (int, off_t);





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

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

extern int  setgroups (int, gid_t []);

extern int  truncate (const char *, off_t);





extern char *crypt (const char *, const char *);
#line 611 "/usr/include/unistd.h"

extern char *_Ecuserid (char *);




extern char *ctermid (char *);
extern void encrypt (char [], int);
extern char *getpass (const char *);
extern int  nice (int);







 







extern int  brk (char *);
extern int  gethostname (char *, int);

extern int  getpagesize (void);
extern pid_t getpgid (pid_t);
extern pid_t getsid (pid_t);
extern char *getwd (char *);
extern int lchown (const char *, uid_t, gid_t);
extern int lockf (int, int, off_t);
#line 657 "/usr/include/unistd.h"
extern void *sbrk (ssize_t);
extern unsigned int ualarm (unsigned int, unsigned int);

extern void sync (void);
#line 680 "/usr/include/unistd.h"
extern int setpgrp (pid_t, pid_t);


extern int  setregid (gid_t, gid_t);
extern int  setreuid (uid_t, uid_t);
extern pid_t vfork (void);
extern int  getdtablesize (void);


extern char *gettxt (const char *, const char *);
extern char *getenv (const char *);
extern int bindresvport (int, struct sockaddr_in *);
extern char *crypt16 (const char *, const char *);
extern int rcmd (char * *, u_short, char *, char *, char *, int *);
extern int rcmd2 (char * *, u_short, char *, char *, char *, int *, int);
extern int rcmd_af (char * *, u_short, int, char *, char *, char *, int *);
extern int rcmd2_af (char * *, u_short, int, char *, char *, char *, int *, int);

extern int rename (const char *, const char *);
extern int rexec (char * *, int, char *, char *, char *, int *);
extern int rexec_af (char * *, int, int, char *, char *, char *, int *);
extern int rresvport (int *);
extern int rresvport2 (int *, int);
extern int rresvport2_af (int *, int, int);
extern int rresvport_af (int *, int);
extern int ruserok (char *, int, char *, char *);
extern int  seteuid (uid_t);
extern int  setegid (gid_t);
extern int  setlogin (char *);
extern int  setrgid (gid_t);
extern int  setruid (uid_t);
extern int  syscall (int, ...);





}
#line 57 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"






 
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/assert.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/assert.h"










 







#line 1 "/usr/include/assert.h"


















 


 


  

 



 


 








 

















 











 


#line 21 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/assert.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 65 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"



#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyconfig.h"
 
 



 

 


 

 


 
 

 
 

 


 


 


 



 
 

 
 

 
 

 
 

 
 


 
 

 
 

 


 
 

 


 


 
 

 
 


 
 


 
 


 
 


 
 

 
 

 
 

 
 

 
 

 


 
 


 
 

 
 

 


 
 

 


 


 


 


 


 


 
 

 
 





 
 

 


 


 
 

 
 

 
 


 


 
 



 
 

 


 


 


 


 


 
 

 


 
 

 
 

 


 


 
 



 
 

 


 


 


 


 



 


 
 

 
 

 
 


 
 

 










  
 



 
 

 
 


 
 

 
 





  
 

 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 
 

 


 


 


 


 


 


 
 

 


 


 


 


 


 


 


 


 
 

 


 


 


 
 

 


 


 


 


 


 


 


 
 

 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 


 


 


 


 
 

 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 


 
 

 


 


 


 


 


 
 

 
 

 


 


 


 
 

 


 


 
 

 


 


 
 

 


 
 

 
 

 


 


 


 


 


 


 


 
 

 
 

 


 


 
 

 
 

 


 


 


 


 


 


 


 


 


 


 


 


 
 

 


 


 
 

 
 

 
 

#line 763 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyconfig.h"

 




#line 5 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"



























 


 
#line 45 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"











 











 
#line 78 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"
typedef unsigned long	Py_uintptr_t;
typedef long		Py_intptr_t;

#line 88 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"










 





#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib_ansi_impl"










 

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::div_t;
using std::exit;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::ldiv_t;
using std::malloc;
using std::mblen;
using std::mbstowcs;
using std::mbtowc;
using std::qsort;
using std::rand;
using std::realloc;
using std::size_t;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;
using std::wcstombs;
using std::wctomb;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 36 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdlib.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 91 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"


#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/math.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/math.h"




























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cmath"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cmath"










 




#line 32 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cmath"

extern "C" {
namespace std {

extern double acos( double );
extern double asin( double );
extern double atan( double );
extern double atan2( double, double );
extern double ceil( double );
extern double cos( double );
extern double cosh( double );
extern double exp( double );
extern double fabs( double );
extern double floor( double );
extern double fmod( double, double );
extern double frexp( double, int * );
extern double ldexp( double, int );
extern double log( double );
extern double log10( double );
extern double modf( double, double * );
extern double pow( double, double );
extern double sin( double );
extern double sinh( double );
extern double sqrt( double );
extern double tan( double );
extern double tanh( double );










extern float acosf ( float );
extern float asinf ( float );
extern float atanf ( float );
extern float atan2f ( float, float );
extern float ceilf ( float );
extern float cosf ( float );
extern float coshf ( float );
extern float expf ( float );
extern float fabsf ( float );
extern float floorf ( float );
extern float fmodf ( float, float );
extern float frexpf ( float, int * );
extern float ldexpf ( float, int );
extern float logf ( float );
extern float log10f ( float );
extern float modff ( float, float * );
extern float powf ( float, float );
extern float sinf ( float );
extern float sinhf ( float );
extern float sqrtf ( float );
extern float tanf ( float );
extern float tanhf ( float );


extern long double acosl( long double );
extern long double asinl( long double );
extern long double atanl( long double );
extern long double atan2l( long double, long double );
extern long double ceill( long double );
extern long double cosl( long double );
extern long double coshl( long double );
extern long double expl( long double );
extern long double fabsl( long double );
extern long double floorl( long double );
extern long double fmodl( long double, long double );
extern long double frexpl( long double, int * );
extern long double ldexpl( long double, int );
extern long double logl( long double );
extern long double log10l( long double );
extern long double modfl( long double, long double * );
extern long double powl( long double, long double );
extern long double sinl( long double );
extern long double sinhl( long double );
extern long double sqrtl( long double );
extern long double tanl( long double );
extern long double tanhl( long double );


}    
}    








extern "C++" {
namespace std {

inline double abs(double _dbl)         { return fabs(_dbl); }
inline double pow(double _dbl, int _i) { return pow (_dbl, (double)_i); }

inline float abs  ( float _flt )               { return fabsf (_flt); }
inline float acos ( float _flt )               { return acosf (_flt); }
inline float asin ( float _flt )               { return asinf (_flt); }
inline float atan ( float _flt )               { return atanf (_flt); }
inline float atan2( float _flt1, float _flt2 ) { return atan2f(_flt1, _flt2); }
inline float ceil ( float _flt )               { return ceilf (_flt); }
inline float cos  ( float _flt )               { return cosf  (_flt); }
inline float cosh ( float _flt )               { return coshf (_flt); }
inline float exp  ( float _flt )               { return expf  (_flt); }
inline float fabs ( float _flt )               { return fabsf (_flt); }
inline float floor( float _flt )               { return floorf(_flt); }
inline float fmod ( float _flt1, float _flt2 ) { return fmodf (_flt1, _flt2); }
inline float frexp( float _flt,  int *_ip )    { return frexpf(_flt,  _ip); }
inline float ldexp( float _flt,  int _i )      { return ldexpf(_flt,  _i); }
inline float log  ( float _flt )               { return logf  (_flt); }
inline float log10( float _flt )               { return log10f(_flt); }
inline float modf ( float _flt,  float *_fp )  { return modff (_flt,  _fp); }
inline float pow  ( float _flt1, float _flt2 ) { return powf  (_flt1, _flt2); }
inline float pow  ( float _flt,  int _i )      { return powf  (_flt,  _i); }
inline float sin  ( float _flt )               { return sinf  (_flt); }
inline float sinh ( float _flt )               { return sinhf (_flt); }
inline float sqrt ( float _flt )               { return sqrtf (_flt); }
inline float tan  ( float _flt )               { return tanf  (_flt); }
inline float tanh ( float _flt )               { return tanhf (_flt); }


inline long double abs  ( long double _ldbl)  { return fabsl (_ldbl); }
inline long double acos ( long double _ldbl)  { return acosl (_ldbl); }
inline long double asin ( long double _ldbl)  { return asinl (_ldbl); }
inline long double atan ( long double _ldbl)  { return atanl (_ldbl); }
inline long double atan2( long double _ldbl1,
                          long double _ldbl2) { return atan2l(_ldbl1, _ldbl2); }
inline long double ceil ( long double _ldbl)  { return ceill (_ldbl); }
inline long double cos  ( long double _ldbl)  { return cosl  (_ldbl); }
inline long double cosh ( long double _ldbl)  { return coshl (_ldbl); }
inline long double exp  ( long double _ldbl)  { return expl  (_ldbl); }
inline long double fabs ( long double _ldbl)  { return fabsl (_ldbl); }
inline long double floor( long double _ldbl)  { return floorl(_ldbl); }
inline long double fmod ( long double _ldbl1,
                          long double _ldbl2) { return fmodl (_ldbl1, _ldbl2); }
inline long double frexp( long double _ldbl, 
                          int *_ip)           { return frexpl(_ldbl,  _ip); }
inline long double ldexp( long double _ldbl, 
                          int _i)             { return ldexpl(_ldbl,  _i); }
inline long double log  ( long double _ldbl)  { return logl  (_ldbl); }
inline long double log10( long double _ldbl)  { return log10l(_ldbl); }
inline long double modf ( long double _ldbl, 
                          long double *_ldp)  { return modfl (_ldbl,  _ldp); }
inline long double pow  ( long double _ldbl1,
                          long double _ldbl2) { return powl  (_ldbl1, _ldbl2); }
inline long double pow  ( long double _ldbl, 
                          int _i)             { return powl  (_ldbl,  (long double)_i); }
inline long double sin  ( long double _ldbl)  { return sinl  (_ldbl); }
inline long double sinh ( long double _ldbl)  { return sinhl (_ldbl); }
inline long double sqrt ( long double _ldbl)  { return sqrtl (_ldbl); }
inline long double tan  ( long double _ldbl)  { return tanl  (_ldbl); }
inline long double tanh ( long double _ldbl)  { return tanhl (_ldbl); }
#line 222 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cmath"

}   
}   






#line 263 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cmath"





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 31 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/math.h"





using std::abs;


using std::acos;
using std::asin;
using std::atan;
using std::atan2;
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::log;
using std::log10;
using std::modf;
using std::pow;
using std::sin;
using std::sinh;
using std::sqrt;
using std::tan;
using std::tanh;










    using std::acosf;
    using std::asinf;
    using std::atanf;
    using std::atan2f;
    using std::ceilf;
    using std::cosf;
    using std::coshf;
    using std::expf;
    using std::fabsf;
    using std::floorf;
    using std::fmodf;
    using std::frexpf;
    using std::ldexpf;
    using std::logf;
    using std::log10f;
    using std::modff;
    using std::powf;
    using std::sinf;
    using std::sinhf;
    using std::sqrtf;
    using std::tanf;
    using std::tanhf;


    using std::acosl;
    using std::asinl;
    using std::atanl;
    using std::atan2l;
    using std::ceill;
    using std::cosl;
    using std::coshl;
    using std::expl;
    using std::fabsl;
    using std::floorl;
    using std::fmodl;
    using std::frexpl;
    using std::ldexpl;
    using std::logl;
    using std::log10l;
    using std::modfl;
    using std::powl;
    using std::sinl;
    using std::sinhl;
    using std::sqrtl;
    using std::tanl;
    using std::tanhl;













#line 159 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/math.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 94 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"



 

#line 1 "/usr/include/sys/time.h"


















 


 


 

 



 


 








 





 




extern "C" {








#line 1 "/usr/include/sys/limits.h"


















 


 


  



 


 















 











                                                                    

#line 65 "/usr/include/sys/time.h"



struct timeval {
	time_t	tv_sec;		 



	int	tv_usec;	 

		 
		 
};

#line 104 "/usr/include/sys/time.h"

struct	itimerval {
	struct		timeval it_interval;  
	struct		timeval it_value;  
};

#line 1 "/usr/include/sys/signal.h"


















 


 



 




 


 









                                                                    




extern "C"
{


#line 1 "/usr/include/sys/siginfo.h"


















 


 


 




extern "C"
{


#line 1 "/usr/include/sys/signalmisc.h"


















 


 


 





















 


 


 




extern "C"
{










 





 

typedef struct  sigaltstack {
        caddr_t ss_sp;                   




        int     ss_flags;                
        size_t  ss_size;                 
} stack_t;






 















 
typedef union sigval {
        int     sival_int;
        void    *sival_ptr;
} sigval_t;


typedef struct sigevent_event {
        union sigval    _sigev_value;    
        int             _sigev_signo;    
        int             _sigev_notify;   
} sigevent_event_t;





typedef struct sigev_event {
        union sigval    _sigev_value;    
        int             _sigev_signo;    
        int             _sigev_notify;   
} sigev_event_t;

typedef struct sigevent {
        sigev_event_t        _sigev_sigevent;
        union {
                int             _sigev[(((64)/sizeof(int)) - 4)];


                struct {
                        



 
                        void (*_sigev_notify_function) (sigval_t);
                        pthread_attr_t *_sigev_notify_attributes;
                } _sigev_un_s;

        } _sigev_un;
} sigevent_t;




 











 








}
#line 35 "/usr/include/sys/siginfo.h"
#line 1 "/usr/include/sys/timemisc.h"


















 


 


 





















 


 


 




extern "C"
{







typedef struct timespec {
        time_t  tv_sec;          
        long    tv_nsec;         
} timespec_t;




 
struct uuprof {                  
        short           *pr_base;        
        unsigned long   pr_size;         
        unsigned long   pr_off;          
        unsigned long   pr_scale;        
};






}
#line 37 "/usr/include/sys/siginfo.h"








 




typedef struct siginfo {



	int si_signo;	 
	int si_errno;	 
	int si_code;	 

	union {
		int _sipad[(((128)/sizeof(int)) - 4)];  

		 
		struct {
			pid_t	_pid;			 
			union {
				 
				struct {
					uid_t	_uid;	 
				} _kill;

				 
				struct {
					int	_status;  
					clock_t _utime;
					clock_t _stime;
				} _sigchld;
			} _pinfo;
			 
			struct {

				 
				sigval_t _sigval;



			} _sigrt;
		} _sigproc;

		 
		struct {



			caddr_t	_addr;	 

		} _sigfault;


		 
		struct {
			long	_band;	 
			 
			int	_fd;	 
		} _sigpoll;

		 
		struct {

 			sigval_t _siganonval;



		} _siganon;
	} _sifields;
} siginfo_t;




 
#line 136 "/usr/include/sys/siginfo.h"




 

 
#line 149 "/usr/include/sys/siginfo.h"






 
#line 167 "/usr/include/sys/siginfo.h"



 
#line 182 "/usr/include/sys/siginfo.h"



 
#line 192 "/usr/include/sys/siginfo.h"



 
#line 203 "/usr/include/sys/siginfo.h"



 








 
#line 226 "/usr/include/sys/siginfo.h"



 
#line 239 "/usr/include/sys/siginfo.h"



 



#line 406 "/usr/include/sys/siginfo.h"


}
#line 55 "/usr/include/sys/signal.h"
















 

#line 82 "/usr/include/sys/signal.h"

extern void (*signal (int, void (*)(int))) (int);







extern int raise (int);





 
#line 130 "/usr/include/sys/signal.h"



 
#line 141 "/usr/include/sys/signal.h"



 

typedef void (*__sigfp)(int);
#line 183 "/usr/include/sys/signal.h"









 





 






 




#line 218 "/usr/include/sys/signal.h"









 
struct sigaction {

	union {
		  
		void	(*_handler) (int);
		void	(*_sigaction) (int, siginfo_t *, void *);
	} _sa_un;





 
#line 250 "/usr/include/sys/signal.h"
	sigset_t sa_mask;	 
	int	sa_flags;	 
	int	sa_signo;	 
};





 
 
extern int kill (pid_t , int); 





#line 274 "/usr/include/sys/signal.h"

extern int sigaction
	(int, const struct sigaction *, struct sigaction *); 












extern int sigprocmask (int, const sigset_t *, sigset_t *);
extern int sigsuspend (const sigset_t *);  
 
extern int sigemptyset (sigset_t *);
extern int sigfillset (sigset_t *);
extern int sigaddset (sigset_t *, int);
extern int sigdelset (sigset_t *, int);
extern int sigismember (const sigset_t *, int);
extern int sigpending (sigset_t *);


 
extern int sigwaitinfo (const sigset_t *, siginfo_t *);

extern int sigtimedwait (const sigset_t *, siginfo_t *, const struct timespec *); 


extern int sigqueue (pid_t, int, const union sigval);










 





extern int pthread_sigmask (int, const sigset_t *, sigset_t *);
extern int pthread_kill (pthread_t, int);








#line 1 "/usr/include/machine/signal.h"


















 


 



  



 


 










                                                                    




extern "C" {



typedef int sig_atomic_t;




#line 130 "/usr/include/machine/signal.h"




 
#line 144 "/usr/include/machine/signal.h"

 
#line 1 "/usr/include/machine/context.h"


















 


 


 




extern "C" {









typedef char *  __caddr_t;














 


struct  sigcontext {




	


 
	long    sc_onstack;		 
	long    sc_mask;		 
	long	sc_pc;			 
	long	sc_ps;			 
	long	sc_regs[32];		 
	long	sc_ownedfp;		 
	long	sc_fpregs[32];		 
	unsigned long sc_fpcr;		 
	unsigned long sc_fp_control;	 
	

 
	long sc_reserved1;		 
	int sc_kreserved1;		 
	int sc_kreserved2;		 



	size_t	sc_ssize;		 

	caddr_t	sc_sbase;		 



	unsigned long sc_traparg_a0;	 
	unsigned long sc_traparg_a1;	 
	unsigned long sc_traparg_a2;	 
	unsigned long sc_fp_trap_pc;	 
	unsigned long sc_fp_trigger_sum;  
	unsigned long sc_fp_trigger_inst;  
};



}
#line 147 "/usr/include/machine/signal.h"








































 

#line 206 "/usr/include/machine/signal.h"

#line 219 "/usr/include/machine/signal.h"



#line 238 "/usr/include/machine/signal.h"


}
#line 334 "/usr/include/sys/signal.h"








 



extern sigset_t cantmasksigset;






 

struct	sigvec {
	void	(*sv_handler) (int);	 
	int     sv_mask;         
	int     sv_flags;    
};                           





 


extern int sigvec (int, struct sigvec *, struct sigvec *);
extern int killpg (pid_t, int);







 

struct  sigstack {



        char    *ss_sp;                  

        int     ss_onstack;              
};




 
extern char *__sys_siglist[];
extern int __sys_nsig;




 
#line 409 "/usr/include/sys/signal.h"







 





 





 
#line 436 "/usr/include/sys/signal.h"





 























 

 


 











#line 489 "/usr/include/sys/signal.h"

extern int sigpause (int);








extern int sigreturn (struct sigcontext *);
extern int sigblock (int);
extern int sigsetmask (int);


extern int sigstack (struct sigstack *, struct sigstack *);
extern int siginterrupt (int, int);

#line 515 "/usr/include/sys/signal.h"
extern int _Psigwait (const sigset_t *set, int *sig);
#line 524 "/usr/include/sys/signal.h"

 
#line 533 "/usr/include/sys/signal.h"

extern void (*sigset (int, void (*)(int))) (int);







extern int sighold (int);
extern int sigrelse (int);

#line 552 "/usr/include/sys/signal.h"

extern int sigignore (int);










extern int sigaltstack (stack_t *, stack_t *);
#line 1 "/usr/include/sys/procset.h"


















 


 















 

typedef enum idop {



	POP_DIFF,	

 

	POP_AND,	

 

	POP_OR,	


 

	POP_XOR	


 






} idop_t;




 

typedef enum idtype {



	P_PID,	 
	P_PPID,	 
	P_PGID,	 
	P_SID,	 
	P_CID,	 
	P_UID,	 
	P_GID,	 
	P_ALL	 
} idtype_t;





 

typedef struct procset {
	idop_t p_op;		


 

	idtype_t p_lidtype;	 
	id_t p_lid;		 

	idtype_t p_ridtype;	 
	id_t p_rid;		 
} procset_t;





 
#line 119 "/usr/include/sys/procset.h"

#line 129 "/usr/include/sys/procset.h"

#line 566 "/usr/include/sys/signal.h"
extern int sigsendset (const procset_t *, int);
extern int sigsend (idtype_t, id_t, int);

int (*ssignal (int, int (*)(int))) (int);
int gsignal (int);



int (*ssignal_r (int, int (*) (int), int (*sigs[])(int))) (int);
int gsignal_r (int, int (*sigs[])(int));








#line 775 "/usr/include/sys/signal.h"




}
#line 112 "/usr/include/sys/time.h"


#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_cname_impl"

extern "C" {
namespace std {

#line 1 "/usr/include/machine/machtime.h"


















 


 


  


















 



 


 


 



 






#line 30 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_cname_impl"








typedef unsigned long 	size_t;

typedef int		clock_t;

typedef int		time_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;        
#line 64 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_cname_impl"
  long    tm_gmtoff;
  char    *tm_zone;





};






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 *);

}    
}    

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_ansi_impl"










 

using std::asctime;
using std::clock;
using std::clock_t;
using std::ctime;
using std::difftime;
using std::gmtime;
using std::localtime;
using std::mktime;
using std::size_t;
using std::strftime;
using std::time;
using std::time_t;
using std::tm;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"
#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"






#line 46 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 134 "/usr/include/sys/time.h"







 



 




 


 








 
#line 170 "/usr/include/sys/time.h"





 
struct timezone {
	int	tz_minuteswest;	 
	int	tz_dsttime;	 
};

#line 189 "/usr/include/sys/time.h"




extern int adjtime (struct timeval *, struct timeval *);
extern int settimeofday (struct timeval *, struct timezone *);



extern int stime (long *);


#line 209 "/usr/include/sys/time.h"
extern int utimes (const char *, struct timeval *);
extern int setitimer (int, struct itimerval *, struct itimerval *);
extern int gettimeofday (struct timeval *, struct timezone *);





extern int getitimer (int, struct itimerval *);






#line 309 "/usr/include/sys/time.h"

#line 344 "/usr/include/sys/time.h"


}
#line 101 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"










 





#line 40 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time_ansi_impl"










 

using std::asctime;
using std::clock;
using std::clock_t;
using std::ctime;
using std::difftime;
using std::gmtime;
using std::localtime;
using std::mktime;
using std::size_t;
using std::strftime;
using std::time;
using std::time_t;
using std::tm;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 43 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/time.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 102 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"
#line 109 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"




 

 





#line 129 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"



 














 












#line 1 "/usr/include/sys/stat.h"


















 


 


  

 



 


 












 




#line 1 "/usr/include/sys/mode.h"


















 


 


  

 



 


 














                                                                    











 






 




					 
#line 86 "/usr/include/sys/mode.h"



 














 

#line 112 "/usr/include/sys/mode.h"









 










 













 



 



#line 55 "/usr/include/sys/stat.h"


extern "C"
{






#line 90 "/usr/include/sys/stat.h"






 





 

#line 111 "/usr/include/sys/stat.h"






#line 168 "/usr/include/sys/stat.h"


#line 200 "/usr/include/sys/stat.h"



  struct stat {
        dev_t st_dev; int st_retired1; mode_t st_mode; nlink_t st_nlink; short st_nlink_reserved; uid_t st_uid; gid_t st_gid; dev_t st_rdev; dev_t st_ldev; off_t st_size; time_t st_retired2; int st_uatime; time_t st_retired3; int st_umtime; time_t st_retired4; int st_uctime; int st_retired5; int st_retired6; uint_t st_flags; uint_t st_gen; long st_spare[4]; ino_t st_ino; int st_ino_reserved; time_t st_atime; int st_atime_reserved; time_t st_mtime; int st_mtime_reserved; time_t st_ctime; int st_ctime_reserved; long st_blksize; long st_blocks;
  };


























 




#line 253 "/usr/include/sys/stat.h"
  




 
#line 269 "/usr/include/sys/stat.h"
      








 
#line 297 "/usr/include/sys/stat.h"
































 



  extern int _F64_stat (const char *, struct stat *);







  extern int _F64_fstat (int , struct stat *);








    extern int _F64_lstat (const char *, struct stat *);







 
#line 368 "/usr/include/sys/stat.h"



extern int	mkdir (const char *, mode_t );
extern mode_t	umask (mode_t );

extern int	chmod (const char *, mode_t );

extern int	fchmod (int, mode_t );



extern int	mknod (const char *, mode_t, ... );


extern int	mkfifo (const char *, mode_t );
 














}


#line 162 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"




















 
extern "C" {
















 
#line 207 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"





 







 
#line 227 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"







 











 





















 











 
#line 287 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"














 
#line 311 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"

#line 322 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"







 

















#line 356 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"






 
#line 382 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"




 








 















 







 

#line 448 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"


 





#line 465 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"









#line 482 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"



 







}




 
#line 505 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyport.h"

#line 67 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pymem.h"

 







extern "C" {





 









 

#line 35 "/usr/local_cci/Python-2.2.1t/include/python2.2/pymem.h"

#line 43 "/usr/local_cci/Python-2.2.1t/include/python2.2/pymem.h"







#line 57 "/usr/local_cci/Python-2.2.1t/include/python2.2/pymem.h"















 




 

 






 
extern void * PyMem_Malloc(size_t);
extern void * PyMem_Realloc(void *, size_t);
extern void PyMem_Free(void *);


 

 







 

 






 



 
#line 125 "/usr/local_cci/Python-2.2.1t/include/python2.2/pymem.h"





 


}






































 


#line 69 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"



extern "C" {



 










































 

#line 62 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"

#line 75 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"




 
typedef struct _object {
	int ob_refcnt; struct _typeobject *ob_type;
} PyObject;

typedef struct {
	int ob_refcnt; struct _typeobject *ob_type; int ob_size;
} PyVarObject;














 

typedef PyObject * (*unaryfunc)(PyObject *);
typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
typedef int (*inquiry)(PyObject *);
typedef int (*coercion)(PyObject **, PyObject **);
typedef PyObject *(*intargfunc)(PyObject *, int);
typedef PyObject *(*intintargfunc)(PyObject *, int, int);
typedef int(*intobjargproc)(PyObject *, int, PyObject *);
typedef int(*intintobjargproc)(PyObject *, int, int, PyObject *);
typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
typedef int (*getreadbufferproc)(PyObject *, int, void **);
typedef int (*getwritebufferproc)(PyObject *, int, void **);
typedef int (*getsegcountproc)(PyObject *, int *);
typedef int (*getcharbufferproc)(PyObject *, int, const char **);
typedef int (*objobjproc)(PyObject *, PyObject *);
typedef int (*visitproc)(PyObject *, void *);
typedef int (*traverseproc)(PyObject *, visitproc, void *);

typedef struct {
	





 

	binaryfunc nb_add;
	binaryfunc nb_subtract;
	binaryfunc nb_multiply;
	binaryfunc nb_divide;
	binaryfunc nb_remainder;
	binaryfunc nb_divmod;
	ternaryfunc nb_power;
	unaryfunc nb_negative;
	unaryfunc nb_positive;
	unaryfunc nb_absolute;
	inquiry nb_nonzero;
	unaryfunc nb_invert;
	binaryfunc nb_lshift;
	binaryfunc nb_rshift;
	binaryfunc nb_and;
	binaryfunc nb_xor;
	binaryfunc nb_or;
	coercion nb_coerce;
	unaryfunc nb_int;
	unaryfunc nb_long;
	unaryfunc nb_float;
	unaryfunc nb_oct;
	unaryfunc nb_hex;
	 
	binaryfunc nb_inplace_add;
	binaryfunc nb_inplace_subtract;
	binaryfunc nb_inplace_multiply;
	binaryfunc nb_inplace_divide;
	binaryfunc nb_inplace_remainder;
	ternaryfunc nb_inplace_power;
	binaryfunc nb_inplace_lshift;
	binaryfunc nb_inplace_rshift;
	binaryfunc nb_inplace_and;
	binaryfunc nb_inplace_xor;
	binaryfunc nb_inplace_or;

	 
	 
	binaryfunc nb_floor_divide;
	binaryfunc nb_true_divide;
	binaryfunc nb_inplace_floor_divide;
	binaryfunc nb_inplace_true_divide;
} PyNumberMethods;

typedef struct {
	inquiry sq_length;
	binaryfunc sq_concat;
	intargfunc sq_repeat;
	intargfunc sq_item;
	intintargfunc sq_slice;
	intobjargproc sq_ass_item;
	intintobjargproc sq_ass_slice;
	objobjproc sq_contains;
	 
	binaryfunc sq_inplace_concat;
	intargfunc sq_inplace_repeat;
} PySequenceMethods;

typedef struct {
	inquiry mp_length;
	binaryfunc mp_subscript;
	objobjargproc mp_ass_subscript;
} PyMappingMethods;

typedef struct {
	getreadbufferproc bf_getreadbuffer;
	getwritebufferproc bf_getwritebuffer;
	getsegcountproc bf_getsegcount;
	getcharbufferproc bf_getcharbuffer;
} PyBufferProcs;
	

typedef void (*destructor)(PyObject *);
typedef int (*printfunc)(PyObject *, FILE *, int);
typedef PyObject *(*getattrfunc)(PyObject *, char *);
typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
typedef int (*cmpfunc)(PyObject *, PyObject *);
typedef PyObject *(*reprfunc)(PyObject *);
typedef long (*hashfunc)(PyObject *);
typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
typedef PyObject *(*getiterfunc) (PyObject *);
typedef PyObject *(*iternextfunc) (PyObject *);
typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
typedef PyObject *(*allocfunc)(struct _typeobject *, int);

typedef struct _typeobject {
	int ob_refcnt; struct _typeobject *ob_type; int ob_size;
	char *tp_name;  
	int tp_basicsize, tp_itemsize;  
	
	 
	
	destructor tp_dealloc;
	printfunc tp_print;
	getattrfunc tp_getattr;
	setattrfunc tp_setattr;
	cmpfunc tp_compare;
	reprfunc tp_repr;
	
	 
	
	PyNumberMethods *tp_as_number;
	PySequenceMethods *tp_as_sequence;
	PyMappingMethods *tp_as_mapping;

	 

	hashfunc tp_hash;
	ternaryfunc tp_call;
	reprfunc tp_str;
	getattrofunc tp_getattro;
	setattrofunc tp_setattro;

	 
	PyBufferProcs *tp_as_buffer;
	
	 
	long tp_flags;

	char *tp_doc;  

	 
	 
	traverseproc tp_traverse;
	
	 
	inquiry tp_clear;

	 
	 
	richcmpfunc tp_richcompare;

	 
	long tp_weaklistoffset;

	 
	 
	getiterfunc tp_iter;
	iternextfunc tp_iternext;

	 
	struct PyMethodDef *tp_methods;
	struct PyMemberDef *tp_members;
	struct PyGetSetDef *tp_getset;
	struct _typeobject *tp_base;
	PyObject *tp_dict;
	descrgetfunc tp_descr_get;
	descrsetfunc tp_descr_set;
	long tp_dictoffset;
	initproc tp_init;
	allocfunc tp_alloc;
	newfunc tp_new;
	destructor tp_free;  
	inquiry tp_is_gc;  
	PyObject *tp_bases;
	PyObject *tp_mro;  
	PyObject *tp_cache;
	PyObject *tp_subclasses;
	PyObject *tp_weaklist;

#line 302 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"
} PyTypeObject;


 
extern int PyType_IsSubtype(PyTypeObject *, PyTypeObject *);



extern PyTypeObject PyType_Type;  
extern PyTypeObject PyBaseObject_Type;  
extern PyTypeObject PySuper_Type;  




extern int PyType_Ready(PyTypeObject *);
extern PyObject * PyType_GenericAlloc(PyTypeObject *, int);
extern PyObject * PyType_GenericNew(PyTypeObject *,
					       PyObject *, PyObject *);
extern PyObject * _PyType_Lookup(PyTypeObject *, PyObject *);

 
extern int PyObject_Print(PyObject *, FILE *, int);
extern void _PyObject_Dump(PyObject *);
extern PyObject * PyObject_Repr(PyObject *);
extern PyObject * PyObject_Str(PyObject *);

extern PyObject * PyObject_Unicode(PyObject *);

extern int PyObject_Compare(PyObject *, PyObject *);
extern PyObject * PyObject_RichCompare(PyObject *, PyObject *, int);
extern int PyObject_RichCompareBool(PyObject *, PyObject *, int);
extern PyObject * PyObject_GetAttrString(PyObject *, char *);
extern int PyObject_SetAttrString(PyObject *, char *, PyObject *);
extern int PyObject_HasAttrString(PyObject *, char *);
extern PyObject * PyObject_GetAttr(PyObject *, PyObject *);
extern int PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
extern int PyObject_HasAttr(PyObject *, PyObject *);
extern PyObject * * _PyObject_GetDictPtr(PyObject *);
extern PyObject * PyObject_GenericGetAttr(PyObject *, PyObject *);
extern int PyObject_GenericSetAttr(PyObject *,
					      PyObject *, PyObject *);
extern long PyObject_Hash(PyObject *);
extern int PyObject_IsTrue(PyObject *);
extern int PyObject_Not(PyObject *);
extern int PyCallable_Check(PyObject *);
extern int PyNumber_Coerce(PyObject **, PyObject **);
extern int PyNumber_CoerceEx(PyObject **, PyObject **);

extern void PyObject_ClearWeakRefs(PyObject *);

 
extern int _PyObject_SlotCompare(PyObject *, PyObject *);






 
extern PyObject * PyObject_Dir(PyObject *);


 
extern int Py_ReprEnter(PyObject *);
extern void Py_ReprLeave(PyObject *);

 
extern long _Py_HashDouble(double);
extern long _Py_HashPointer(void*);

 


 























 

 


 



 


 


 


 


 


 


 


 


 


 


 


 






#line 458 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"





























 







#line 502 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"

#line 512 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"





#line 537 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"







#line 551 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"

 









 

extern PyObject _Py_NoneStruct;  






 

extern PyObject _Py_NotImplementedStruct;  



 
#line 584 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"















 

#line 608 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"


















































 

























 



#line 702 "/usr/local_cci/Python-2.2.1t/include/python2.2/object.h"
extern void _PyTrash_deposit_object(PyObject*);
extern void _PyTrash_destroy_chain(void);

extern int _PyTrash_delete_nesting;
extern PyObject * _PyTrash_delete_later;

 





}
#line 71 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"







extern "C" {
















































 




 














 

#line 85 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"

#line 93 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"

#line 101 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"







#line 115 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"




 










 

 





 
extern void * PyObject_Malloc(size_t);
extern void * PyObject_Realloc(void *, size_t);
extern void PyObject_Free(void *);

 







 

 
extern PyObject * PyObject_Init(PyObject *, PyTypeObject *);
extern PyVarObject * PyObject_InitVar(PyVarObject *,
                                                 PyTypeObject *, int);
extern PyObject * _PyObject_New(PyTypeObject *);
extern PyVarObject * _PyObject_NewVar(PyTypeObject *, int);
extern void _PyObject_Del(PyObject *);








 
















 




#line 197 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"







































 








 

 


 



extern PyObject * _PyObject_GC_Malloc(PyTypeObject *, int);
extern PyVarObject * _PyObject_GC_Resize(PyVarObject *, int);




extern PyObject * _PyObject_GC_New(PyTypeObject *);
extern PyVarObject * _PyObject_GC_NewVar(PyTypeObject *, int);
extern void _PyObject_GC_Del(PyObject *);
extern void _PyObject_GC_Track(PyObject *);
extern void _PyObject_GC_UnTrack(PyObject *);



 
typedef union _gc_head {
	struct {
		union _gc_head *gc_next;  
		union _gc_head *gc_prev;
		int gc_refs;
	} gc;
	double dummy;   
} PyGC_Head;

extern PyGC_Head _PyGC_generation0;


 
#line 291 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"

 
#line 299 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"











#line 321 "/usr/local_cci/Python-2.2.1t/include/python2.2/objimpl.h"



 







 








}
#line 72 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pydebug.h"




extern "C" {


extern int Py_DebugFlag;
extern int Py_VerboseFlag;
extern int Py_InteractiveFlag;
extern int Py_OptimizeFlag;
extern int Py_NoSiteFlag;
extern int Py_UseClassExceptionsFlag;
extern int Py_FrozenFlag;
extern int Py_TabcheckFlag;
extern int Py_UnicodeFlag;
extern int Py_IgnoreEnvironmentFlag;
extern int Py_DivisionWarningFlag;


 
extern int _Py_QnewFlag;



 


void Py_FatalError(char *message);


}
#line 74 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"




















































 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype_cname_impl"

extern "C" {
namespace std {


extern int	isalpha (int);
extern int	isalnum (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	toupper (int);
extern int	tolower (int);

}   
}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype_ansi_impl"










 

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;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype.h"





#line 36 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/ctype.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 56 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"

 

 

#line 67 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"



 






 






 
 
 

 
#line 102 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"



 








 
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"

namespace std {

#line 29 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"



typedef unsigned int wint_t;          

typedef unsigned long   size_t;


}  

#line 52 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
namespace std {

#line 61 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
typedef struct {
    void	*__hdr;		 
    void	*__attrobj;	 
    void	*__state;	 
} mbstate_t;

}  



namespace std {






extern "C" {

extern const 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 const wchar_t  *wcsstr (const wchar_t *, const wchar_t *);
extern int	wscanf (const wchar_t *, ...);
extern int	swscanf (const wchar_t *, const wchar_t *, ...);


extern int	fwscanf (FILE *, const wchar_t *, ...);
extern int	fwprintf (FILE *, const wchar_t *, ...);
extern wint_t	fgetwc (FILE *);
extern wchar_t  *fgetws (wchar_t *, int, FILE *);
extern wint_t	fputwc (wchar_t,FILE *);
extern int	fputws (const wchar_t *, FILE *);
extern wint_t	getwc (FILE *);
extern wint_t	putwc (wchar_t, FILE *);
extern int      fwide (FILE *, int);
extern wint_t	ungetwc (wint_t, FILE *);
#line 110 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
extern int	wprintf (const wchar_t *, ...);
extern int	swprintf (wchar_t *, size_t, const wchar_t *, ...);
extern wint_t	btowc (int);
extern int	wctob (wint_t);
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	wcrtomb (char *, wchar_t, mbstate_t *);
extern size_t	mbsrtowcs (wchar_t *, const char **, size_t, mbstate_t *);
extern size_t	wcsrtombs (char *, const wchar_t **, size_t, mbstate_t *);
extern wint_t	getwchar (void);
extern wint_t	putwchar (wchar_t);
extern double	wcstod (const wchar_t *, wchar_t **);
extern long int	wcstol (const wchar_t *, wchar_t **, int);
extern unsigned long int wcstoul (const wchar_t *, wchar_t **, int);
extern wchar_t	*wcscat (wchar_t *, const wchar_t *);
extern const 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 const wchar_t	*wcspbrk (const wchar_t *, const wchar_t *);
extern const wchar_t	*wcsrchr (const wchar_t *, wchar_t);
extern size_t	wcsspn (const wchar_t *, const wchar_t *);
#line 145 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
extern size_t	wcsxfrm (wchar_t *, const wchar_t *, size_t);

}   

 
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ovrld_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ovrld_impl"










 


 




#line 26 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ovrld_impl"

extern "C++" {

   inline wchar_t *wcschr (wchar_t * _s, wchar_t _c) {
         return (wchar_t *) wcschr((const wchar_t*)_s, _c);
   }
   inline wchar_t *wcspbrk (wchar_t * _s1, const wchar_t * _s2) {
         return (wchar_t*) wcspbrk((const wchar_t*)_s1, _s2);
   }
   inline wchar_t *wcsrchr (wchar_t * _s, wchar_t _c) {
         return (wchar_t*) wcsrchr((const wchar_t*)_s, _c);
   }
   inline wchar_t  *wcsstr (wchar_t * _s1, const wchar_t * _s2) {
         return (wchar_t*) wcsstr((const wchar_t*)_s1, _s2);
   }
   inline wchar_t *wmemchr (wchar_t * _s, wchar_t _c, size_t _n) {
         return (wchar_t*) wmemchr((const wchar_t*)_s, _c, _n);
   }

}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 151 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"

}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"










 

using std::btowc;


using std::fwscanf;
using std::fwprintf;
using std::fgetwc;
using std::fgetws;
using std::fputwc;
using std::fputws;
using std::getwc;
using std::putwc;
using std::fwide;
using std::ungetwc;
#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"

using std::getwchar;
using std::mbrlen;
using std::mbrtowc;
using std::mbsinit;
using std::mbsrtowcs;
using std::mbstate_t;
using std::putwchar;
using std::size_t;
using std::swprintf;
using std::swscanf;
using std::wcrtomb;
using std::wcscat;
using std::wcschr;
using std::wcscmp;
using std::wcscoll;
using std::wcscpy;
using std::wcscspn;



using std::wcslen;
using std::wcsncat;
using std::wcsncmp;
using std::wcsncpy;
using std::wcspbrk;
using std::wcsrchr;
using std::wcsrtombs;
using std::wcsspn;
using std::wcsstr;
using std::wcstod;



using std::wcstol;
using std::wcstoul;
using std::wcsxfrm;
using std::wctob;
using std::wint_t;
using std::wmemchr;
using std::wmemcmp;
using std::wmemcpy;
using std::wmemmove;
using std::wmemset;
using std::wprintf;
using std::wscanf;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"
#line 31 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"

#line 39 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 119 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"





 

typedef unsigned int Py_UCS4; 




typedef unsigned short Py_UNICODE;

 




 



#line 209 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"

#line 282 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"

 




 

#line 316 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"











































extern "C" {


 

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    int length;			 
    Py_UNICODE *str;		 
    long hash;			 
    PyObject *defenc;		

 
} PyUnicodeObject;

extern PyTypeObject PyUnicode_Type;




 
#line 388 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"

 




 



 

 









 

extern PyObject* PyUnicodeUCS2_FromUnicode(
    const Py_UNICODE *u,         
    int size                     
    );


 

extern Py_UNICODE * PyUnicodeUCS2_AsUnicode(
    PyObject *unicode	 	 
    );

 

extern int PyUnicodeUCS2_GetSize(
    PyObject *unicode	 	 
    );

 
extern Py_UNICODE PyUnicodeUCS2_GetMax(void);













 

extern int PyUnicodeUCS2_Resize(
    PyObject **unicode,		 
    int length			 
    );
















 

extern PyObject* PyUnicodeUCS2_FromEncodedObject(
    register PyObject *obj, 	 
    const char *encoding,        
    const char *errors           
    );












 

extern PyObject* PyUnicodeUCS2_FromObject(
    register PyObject *obj 	 
    );

 






 

extern PyObject* PyUnicodeUCS2_FromWideChar(
    register const wchar_t *w,   
    int size                     
    );





 

extern int PyUnicodeUCS2_AsWideChar(
    PyUnicodeObject *unicode,    
    register wchar_t *w,         
    int size                     
    );



















 

 













 

extern PyObject * _PyUnicodeUCS2_AsDefaultEncodedString(
    PyObject *, const char *);








 

extern const char* PyUnicodeUCS2_GetDefaultEncoding(void);





 

extern int PyUnicodeUCS2_SetDefaultEncoding(
    const char *encoding	 
    );

 


 

extern PyObject* PyUnicodeUCS2_Decode(
    const char *s,               
    int size,                    
    const char *encoding,        
    const char *errors           
    );


 

extern PyObject* PyUnicodeUCS2_Encode(
    const Py_UNICODE *s,         
    int size,                    
    const char *encoding,        
    const char *errors           
    );


 

extern PyObject* PyUnicodeUCS2_AsEncodedString(
    PyObject *unicode,	 	 
    const char *encoding,	 
    const char *errors		 
    );

 

extern PyObject* PyUnicode_DecodeUTF7(
    const char *string, 	 
    int length,	 		 
    const char *errors		 
    );

extern PyObject* PyUnicode_EncodeUTF7(
    const Py_UNICODE *data, 	 
    int length,	 		 
    int encodeSetO,             
 
    int encodeWhiteSpace,       
 
    const char *errors		 
    );

 

extern PyObject* PyUnicodeUCS2_DecodeUTF8(
    const char *string, 	 
    int length,	 		 
    const char *errors		 
    );

extern PyObject* PyUnicodeUCS2_AsUTF8String(
    PyObject *unicode	 	 
    );

extern PyObject* PyUnicodeUCS2_EncodeUTF8(
    const Py_UNICODE *data, 	 
    int length,	 		 
    const char *errors		 
    );

 






















 

extern PyObject* PyUnicodeUCS2_DecodeUTF16(
    const char *string, 	 
    int length,	 		 
    const char *errors,		 
    int *byteorder		

 
    );


 

extern PyObject* PyUnicodeUCS2_AsUTF16String(
    PyObject *unicode	 	 
    );



















 

extern PyObject* PyUnicodeUCS2_EncodeUTF16(
    const Py_UNICODE *data, 	 
    int length,	 		 
    const char *errors,		 
    int byteorder		 
    );

 

extern PyObject* PyUnicodeUCS2_DecodeUnicodeEscape(
    const char *string, 	 
    int length,	 		 
    const char *errors		 
    );

extern PyObject* PyUnicodeUCS2_AsUnicodeEscapeString(
    PyObject *unicode	 	 
    );

extern PyObject* PyUnicodeUCS2_EncodeUnicodeEscape(
    const Py_UNICODE *data, 	 
    int length	 		 
    );

 

extern PyObject* PyUnicodeUCS2_DecodeRawUnicodeEscape(
    const char *string, 	 
    int length,	 		 
    const char *errors		 
    );

extern PyObject* PyUnicodeUCS2_AsRawUnicodeEscapeString(
    PyObject *unicode	 	 
    );

extern PyObject* PyUnicodeUCS2_EncodeRawUnicodeEscape(
    const Py_UNICODE *data, 	 
    int length	 		 
    );





 

extern PyObject* PyUnicodeUCS2_DecodeLatin1(
    const char *string, 	 
    int length,	 		 
    const char *errors		 
    );

extern PyObject* PyUnicodeUCS2_AsLatin1String(
    PyObject *unicode	 	 
    );

extern PyObject* PyUnicodeUCS2_EncodeLatin1(
    const Py_UNICODE *data, 	 
    int length,	 		 
    const char *errors		 
    );





 

extern PyObject* PyUnicodeUCS2_DecodeASCII(
    const char *string, 	 
    int length,	 		 
    const char *errors		 
    );

extern PyObject* PyUnicodeUCS2_AsASCIIString(
    PyObject *unicode	 	 
    );

extern PyObject* PyUnicodeUCS2_EncodeASCII(
    const Py_UNICODE *data, 	 
    int length,	 		 
    const char *errors		 
    );





















 

extern PyObject* PyUnicodeUCS2_DecodeCharmap(
    const char *string, 	 
    int length,	 		 
    PyObject *mapping,		
 
    const char *errors		 
    );

extern PyObject* PyUnicodeUCS2_AsCharmapString(
    PyObject *unicode,	 	 
    PyObject *mapping		
 
    );

extern PyObject* PyUnicodeUCS2_EncodeCharmap(
    const Py_UNICODE *data, 	 
    int length,	 		 
    PyObject *mapping,		
 
    const char *errors		 
    );












 

extern PyObject * PyUnicodeUCS2_TranslateCharmap(
    const Py_UNICODE *data, 	 
    int length,	 		 
    PyObject *table,		 
    const char *errors		 
    );

#line 876 "/usr/local_cci/Python-2.2.1t/include/python2.2/unicodeobject.h"

 





















 

extern int PyUnicodeUCS2_EncodeDecimal(
    Py_UNICODE *s,		 
    int length,			 
    char *output,		 
    const char *errors		 
    );





 

 

extern PyObject* PyUnicodeUCS2_Concat(
    PyObject *left,	 	 
    PyObject *right	 	 
    );










 

extern PyObject* PyUnicodeUCS2_Split(
    PyObject *s,		 
    PyObject *sep,		 
    int maxsplit		 
    );		




 
    
extern PyObject* PyUnicodeUCS2_Splitlines(
    PyObject *s,		 
    int keepends		 
    );		











 

extern PyObject * PyUnicodeUCS2_Translate(
    PyObject *str,		  
    PyObject *table,		 
    const char *errors		 
    );


 
    
extern PyObject* PyUnicodeUCS2_Join(
    PyObject *separator, 	 
    PyObject *seq	 	 
    );


 

extern int PyUnicodeUCS2_Tailmatch(
    PyObject *str,		  
    PyObject *substr,		 
    int start,			 
    int end,			 
    int direction		 
    );


 

extern int PyUnicodeUCS2_Find(
    PyObject *str,		  
    PyObject *substr,		 
    int start,			 
    int end,			 
    int direction		 
    );

 

extern int PyUnicodeUCS2_Count(
    PyObject *str,		  
    PyObject *substr,		 
    int start,			 
    int end			 
    );


 

extern PyObject * PyUnicodeUCS2_Replace(
    PyObject *str,		  
    PyObject *substr,		 
    PyObject *replstr,		 
    int maxcount		
 
    );


 

extern int PyUnicodeUCS2_Compare(
    PyObject *left,		  
    PyObject *right		 
    );


 

extern PyObject * PyUnicodeUCS2_Format(
    PyObject *format,		  
    PyObject *args		 
    );





 

extern int PyUnicodeUCS2_Contains(
    PyObject *container,	  
    PyObject *element		 
    );

 






 

extern int _PyUnicodeUCS2_IsLowercase(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsUppercase(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsTitlecase(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsWhitespace(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsLinebreak(
    Py_UNICODE ch 	 
    );

extern Py_UNICODE _PyUnicodeUCS2_ToLowercase(
    Py_UNICODE ch 	 
    );

extern Py_UNICODE _PyUnicodeUCS2_ToUppercase(
    Py_UNICODE ch 	 
    );

extern Py_UNICODE _PyUnicodeUCS2_ToTitlecase(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_ToDecimalDigit(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_ToDigit(
    Py_UNICODE ch 	 
    );

extern double _PyUnicodeUCS2_ToNumeric(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsDecimalDigit(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsDigit(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsNumeric(
    Py_UNICODE ch 	 
    );

extern int _PyUnicodeUCS2_IsAlpha(
    Py_UNICODE ch 	 
    );


}
#line 76 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/intobject.h"

 












 




extern "C" {


typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    long ob_ival;
} PyIntObject;

extern PyTypeObject PyInt_Type;




extern PyObject * PyInt_FromString(char*, char**, int);

extern PyObject * PyInt_FromUnicode(Py_UNICODE*, int, int);

extern PyObject * PyInt_FromLong(long);
extern long PyInt_AsLong(PyObject *);
extern long PyInt_GetMax(void);









 

extern PyIntObject _Py_ZeroStruct, _Py_TrueStruct;  




 







 
extern unsigned long PyOS_strtoul(char *, char **, int);
extern long PyOS_strtol(char *, char **, int);


}
#line 77 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/longobject.h"



extern "C" {



 

typedef struct _longobject PyLongObject;  

extern PyTypeObject PyLong_Type;




extern PyObject * PyLong_FromLong(long);
extern PyObject * PyLong_FromUnsignedLong(unsigned long);
extern PyObject * PyLong_FromDouble(double);
extern long PyLong_AsLong(PyObject *);
extern unsigned long PyLong_AsUnsignedLong(PyObject *);






 
extern double _PyLong_AsScaledDouble(PyObject *vv, int *e);

extern double PyLong_AsDouble(PyObject *);
extern PyObject * PyLong_FromVoidPtr(void *);
extern void * PyLong_AsVoidPtr(PyObject *);



 
#line 47 "/usr/local_cci/Python-2.2.1t/include/python2.2/longobject.h"

extern PyObject * PyLong_FromLongLong(long long);
extern PyObject * PyLong_FromUnsignedLongLong(unsigned long long);
extern long long PyLong_AsLongLong(PyObject *);
extern unsigned long long PyLong_AsUnsignedLongLong(PyObject *);


PyObject * PyLong_FromString(char *, char **, int);

PyObject * PyLong_FromUnicode(Py_UNICODE*, int, int);














 
extern PyObject * _PyLong_FromByteArray(
	const unsigned char* bytes, size_t n,
	int little_endian, int is_signed);



















 
extern int _PyLong_AsByteArray(PyLongObject* v,
	unsigned char* bytes, size_t n,
	int little_endian, int is_signed);


}
#line 78 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/floatobject.h"

 



 




extern "C" {


typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    double ob_fval;
} PyFloatObject;

extern PyTypeObject PyFloat_Type;






 
extern PyObject * PyFloat_FromString(PyObject*, char** junk);

 
extern PyObject * PyFloat_FromDouble(double);


 
extern double PyFloat_AsDouble(PyObject *);





 
extern void PyFloat_AsReprString(char*, PyFloatObject *v);





 
extern void PyFloat_AsString(char*, PyFloatObject *v);


}
#line 79 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/complexobject.h"
 




extern "C" {


typedef struct {
    double real;
    double imag;
} Py_complex;

 

#line 22 "/usr/local_cci/Python-2.2.1t/include/python2.2/complexobject.h"

extern Py_complex _Py_c_sum(Py_complex, Py_complex);
extern Py_complex _Py_c_diff(Py_complex, Py_complex);
extern Py_complex _Py_c_neg(Py_complex);
extern Py_complex _Py_c_prod(Py_complex, Py_complex);
extern Py_complex _Py_c_quot(Py_complex, Py_complex);
extern Py_complex _Py_c_pow(Py_complex, Py_complex);


 




 

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    Py_complex cval;
} PyComplexObject;     

extern PyTypeObject PyComplex_Type;




extern PyObject * PyComplex_FromCComplex(Py_complex);
extern PyObject * PyComplex_FromDoubles(double real, double imag);

extern double PyComplex_RealAsDouble(PyObject *op);
extern double PyComplex_ImagAsDouble(PyObject *op);
extern Py_complex PyComplex_AsCComplex(PyObject *op);


}
#line 81 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/rangeobject.h"

 




extern "C" {








 

extern PyTypeObject PyRange_Type;



extern PyObject * PyRange_New(long, long, long, int);


}
#line 83 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/stringobject.h"

 




extern "C" {


#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"










 










namespace std {
#line 1 "/usr/include/stdarg.h"


















 


 
 
 








#line 1 "/usr/include/va_list.h"


















 


 


 



 


 











 
 















 



typedef struct {
	char	**_a0;		 
	int	_offset;		 
} va_list;

#line 34 "/usr/include/stdarg.h"





#line 54 "/usr/include/stdarg.h"

#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
}    
using std::va_list;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"

#line 43 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"

extern "C" {
namespace std {

typedef unsigned long   size_t;




typedef long    fpos_t;


}    
}    

#line 72 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"







 
#line 89 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"









extern "C" {

#line 163 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"


#line 173 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_cname_impl"
extern std::FILE	_iob[];





}    


extern "C" {
namespace std {

extern size_t	fread (void *, size_t, size_t, FILE *);
extern size_t	fwrite (const void *, size_t, size_t, FILE *);

extern int 	ferror (FILE *);
extern int 	feof (FILE *);
extern void 	clearerr (FILE *);
extern int 	putchar (int);
extern int 	getchar (void);
extern int 	putc (int, FILE *);
extern int 	getc (FILE *);
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 char 	*gets (char *);
extern int 	puts (const char *);
extern int	ungetc (int, 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 	perror (const char *);

}   
}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdio_ansi_impl"










 

using std::FILE;
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::fpos_t;
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;

using std::size_t;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"

namespace std {

#line 29 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"



typedef unsigned int wint_t;          

typedef unsigned long   size_t;


}  

#line 70 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"

namespace std {






extern "C" {

extern const 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 const wchar_t  *wcsstr (const wchar_t *, const wchar_t *);
extern int	wscanf (const wchar_t *, ...);
extern int	swscanf (const wchar_t *, const wchar_t *, ...);


extern int	fwscanf (FILE *, const wchar_t *, ...);
extern int	fwprintf (FILE *, const wchar_t *, ...);
extern wint_t	fgetwc (FILE *);
extern wchar_t  *fgetws (wchar_t *, int, FILE *);
extern wint_t	fputwc (wchar_t,FILE *);
extern int	fputws (const wchar_t *, FILE *);
extern wint_t	getwc (FILE *);
extern wint_t	putwc (wchar_t, FILE *);
extern int      fwide (FILE *, int);
extern wint_t	ungetwc (wint_t, FILE *);


extern int	vfwprintf (FILE *, const wchar_t *, va_list);




extern int	vswprintf (wchar_t *, size_t, const wchar_t *, va_list);
extern int	vwprintf (const wchar_t *, va_list);

extern int	wprintf (const wchar_t *, ...);
extern int	swprintf (wchar_t *, size_t, const wchar_t *, ...);
extern wint_t	btowc (int);
extern int	wctob (wint_t);
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	wcrtomb (char *, wchar_t, mbstate_t *);
extern size_t	mbsrtowcs (wchar_t *, const char **, size_t, mbstate_t *);
extern size_t	wcsrtombs (char *, const wchar_t **, size_t, mbstate_t *);
extern wint_t	getwchar (void);
extern wint_t	putwchar (wchar_t);
extern double	wcstod (const wchar_t *, wchar_t **);
extern long int	wcstol (const wchar_t *, wchar_t **, int);
extern unsigned long int wcstoul (const wchar_t *, wchar_t **, int);
extern wchar_t	*wcscat (wchar_t *, const wchar_t *);
extern const 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 const wchar_t	*wcspbrk (const wchar_t *, const wchar_t *);
extern const wchar_t	*wcsrchr (const wchar_t *, wchar_t);
extern size_t	wcsspn (const wchar_t *, const wchar_t *);
#line 145 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_cname_impl"
extern size_t	wcsxfrm (wchar_t *, const wchar_t *, size_t);

}   

 


}   

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 42 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"










 

using std::btowc;


using std::fwscanf;
using std::fwprintf;
using std::fgetwc;
using std::fgetws;
using std::fputwc;
using std::fputws;
using std::getwc;
using std::putwc;
using std::fwide;
using std::ungetwc;

using std::vfwprintf;



using std::vswprintf;
using std::vwprintf;


using std::getwchar;
using std::mbrlen;
using std::mbrtowc;
using std::mbsinit;
using std::mbsrtowcs;
using std::mbstate_t;
using std::putwchar;
using std::size_t;
using std::swprintf;
using std::swscanf;
using std::wcrtomb;
using std::wcscat;
using std::wcschr;
using std::wcscmp;
using std::wcscoll;
using std::wcscpy;
using std::wcscspn;



using std::wcslen;
using std::wcsncat;
using std::wcsncmp;
using std::wcsncpy;
using std::wcspbrk;
using std::wcsrchr;
using std::wcsrtombs;
using std::wcsspn;
using std::wcsstr;
using std::wcstod;



using std::wcstol;
using std::wcstoul;
using std::wcsxfrm;
using std::wctob;
using std::wint_t;
using std::wmemchr;
using std::wmemcmp;
using std::wmemcpy;
using std::wmemmove;
using std::wmemset;
using std::wprintf;
using std::wscanf;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 43 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"







#line 57 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 11 "/usr/local_cci/Python-2.2.1t/include/python2.2/stringobject.h"














 









 





typedef struct {
    int ob_refcnt; struct _typeobject *ob_type; int ob_size;

    long ob_shash;


    PyObject *ob_sinterned;

    char ob_sval[1];
} PyStringObject;

extern PyTypeObject PyString_Type;




extern PyObject * PyString_FromStringAndSize(const char *, int);
extern PyObject * PyString_FromString(const char *);
extern PyObject * PyString_FromFormatV(const char*, va_list)
				;
extern PyObject * PyString_FromFormat(const char*, ...)
				;
extern int PyString_Size(PyObject *);
extern char * PyString_AsString(PyObject *);
extern void PyString_Concat(PyObject **, PyObject *);
extern void PyString_ConcatAndDel(PyObject **, PyObject *);
extern int _PyString_Resize(PyObject **, int);
extern int _PyString_Eq(PyObject *, PyObject*);
extern PyObject * PyString_Format(PyObject *, PyObject *);
extern PyObject * _PyString_FormatLong(PyObject*, int, int,
						  int, char**, int*);


extern void PyString_InternInPlace(PyObject **);
extern PyObject * PyString_InternFromString(const char *);
extern void _Py_ReleaseInternedStrings(void);






 




 
extern PyObject * _PyString_Join(PyObject *sep, PyObject *x);

 


 

extern PyObject* PyString_Decode(
    const char *s,               
    int size,                    
    const char *encoding,        
    const char *errors           
    );


 

extern PyObject* PyString_Encode(
    const char *s,               
    int size,                    
    const char *encoding,        
    const char *errors           
    );


 

extern PyObject* PyString_AsEncodedObject(
    PyObject *str,	 	 
    const char *encoding,	 
    const char *errors		 
    );







 

extern PyObject* PyString_AsEncodedString(
    PyObject *str,	 	 
    const char *encoding,	 
    const char *errors		 
    );


 

extern PyObject* PyString_AsDecodedObject(
    PyObject *str,	 	 
    const char *encoding,	 
    const char *errors		 
    );







 

extern PyObject* PyString_AsDecodedString(
    PyObject *str,	 	 
    const char *encoding,	 
    const char *errors		 
    );





 

extern int PyString_AsStringAndSize(
    register PyObject *obj,	 
    register char **s,		 
    register int *len		

 
    );
    


}
#line 84 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/bufferobject.h"

 

 




extern "C" {



extern PyTypeObject PyBuffer_Type;





extern PyObject * PyBuffer_FromObject(PyObject *base,
                                                 int offset, int size);
extern PyObject * PyBuffer_FromReadWriteObject(PyObject *base,
                                                          int offset,
                                                          int size);

extern PyObject * PyBuffer_FromMemory(void *ptr, int size);
extern PyObject * PyBuffer_FromReadWriteMemory(void *ptr, int size);

extern PyObject * PyBuffer_New(int size);


}
#line 85 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/tupleobject.h"

 




extern "C" {












 

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type; int ob_size;
    PyObject *ob_item[1];
} PyTupleObject;

extern PyTypeObject PyTuple_Type;




extern PyObject * PyTuple_New(int size);
extern int PyTuple_Size(PyObject *);
extern PyObject * PyTuple_GetItem(PyObject *, int);
extern int PyTuple_SetItem(PyObject *, int, PyObject *);
extern PyObject * PyTuple_GetSlice(PyObject *, int, int);
extern int _PyTuple_Resize(PyObject **, int);

 



 



}
#line 86 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/listobject.h"

 











 




extern "C" {


typedef struct {
    int ob_refcnt; struct _typeobject *ob_type; int ob_size;
    PyObject **ob_item;
} PyListObject;

extern PyTypeObject PyList_Type;




extern PyObject * PyList_New(int size);
extern int PyList_Size(PyObject *);
extern PyObject * PyList_GetItem(PyObject *, int);
extern int PyList_SetItem(PyObject *, int, PyObject *);
extern int PyList_Insert(PyObject *, int, PyObject *);
extern int PyList_Append(PyObject *, PyObject *);
extern PyObject * PyList_GetSlice(PyObject *, int, int);
extern int PyList_SetSlice(PyObject *, int, int, PyObject *);
extern int PyList_Sort(PyObject *);
extern int PyList_Reverse(PyObject *);
extern PyObject * PyList_AsTuple(PyObject *);

 





}
#line 87 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/dictobject.h"



extern "C" {



 























 








 


typedef struct {
	long me_hash;       
	PyObject *me_key;
	PyObject *me_value;



} PyDictEntry;









 
typedef struct _dictobject PyDictObject;
struct _dictobject {
	int ob_refcnt; struct _typeobject *ob_type;
	int ma_fill;   
	int ma_used;   

	


 
	int ma_mask;

	



 
	PyDictEntry *ma_table;
	PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
	PyDictEntry ma_smalltable[8];
};

extern PyTypeObject PyDict_Type;



extern PyObject * PyDict_New(void);
extern PyObject * PyDict_GetItem(PyObject *mp, PyObject *key);
extern int PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
extern int PyDict_DelItem(PyObject *mp, PyObject *key);
extern void PyDict_Clear(PyObject *mp);
extern int PyDict_Next
	(PyObject *mp, int *pos, PyObject **key, PyObject **value);
extern PyObject * PyDict_Keys(PyObject *mp);
extern PyObject * PyDict_Values(PyObject *mp);
extern PyObject * PyDict_Items(PyObject *mp);
extern int PyDict_Size(PyObject *mp);
extern PyObject * PyDict_Copy(PyObject *mp);

 
extern int PyDict_Update(PyObject *mp, PyObject *other);





 
extern int PyDict_Merge(PyObject *mp,
				   PyObject *other,
				   int override);





 
extern int PyDict_MergeFromSeq2(PyObject *d,
					   PyObject *seq2,
					   int override);

extern PyObject * PyDict_GetItemString(PyObject *dp, char *key);
extern int PyDict_SetItemString(PyObject *dp, char *key, PyObject *item);
extern int PyDict_DelItemString(PyObject *dp, char *key);


}
#line 88 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/methodobject.h"

 




extern "C" {


extern PyTypeObject PyCFunction_Type;



typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
					     PyObject *);
typedef PyObject *(*PyNoArgsFunction)(PyObject *);

extern PyCFunction PyCFunction_GetFunction(PyObject *);
extern PyObject * PyCFunction_GetSelf(PyObject *);
extern int PyCFunction_GetFlags(PyObject *);


 
#line 31 "/usr/local_cci/Python-2.2.1t/include/python2.2/methodobject.h"
extern PyObject * PyCFunction_Call(PyObject *, PyObject *, PyObject *);

struct PyMethodDef {
    char	*ml_name;
    PyCFunction  ml_meth;
    int		 ml_flags;
    char	*ml_doc;
};
typedef struct PyMethodDef PyMethodDef;

extern PyObject * Py_FindMethod(PyMethodDef[], PyObject *, char *);

extern PyObject * PyCFunction_New(PyMethodDef *, PyObject *);

 



 



typedef struct PyMethodChain {
    PyMethodDef *methods;		 
    struct PyMethodChain *link;	 
} PyMethodChain;

extern PyObject * Py_FindMethodInChain(PyMethodChain *, PyObject *,
                                                  char *);

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    PyMethodDef *m_ml;
    PyObject    *m_self;
} PyCFunctionObject;


}
#line 89 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/moduleobject.h"

 




extern "C" {


extern PyTypeObject PyModule_Type;




extern PyObject * PyModule_New(char *);
extern PyObject * PyModule_GetDict(PyObject *);
extern char * PyModule_GetName(PyObject *);
extern char * PyModule_GetFilename(PyObject *);
extern void _PyModule_Clear(PyObject *);


}
#line 90 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/funcobject.h"

 




extern "C" {


typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    PyObject *func_code;
    PyObject *func_globals;
    PyObject *func_defaults;
    PyObject *func_closure;
    PyObject *func_doc;
    PyObject *func_name;
    PyObject *func_dict;
    PyObject *func_weakreflist;
} PyFunctionObject;

extern PyTypeObject PyFunction_Type;



extern PyObject * PyFunction_New(PyObject *, PyObject *);
extern PyObject * PyFunction_GetCode(PyObject *);
extern PyObject * PyFunction_GetGlobals(PyObject *);
extern PyObject * PyFunction_GetDefaults(PyObject *);
extern int PyFunction_SetDefaults(PyObject *, PyObject *);
extern PyObject * PyFunction_GetClosure(PyObject *);
extern int PyFunction_SetClosure(PyObject *, PyObject *);


 
#line 44 "/usr/local_cci/Python-2.2.1t/include/python2.2/funcobject.h"

 
extern PyTypeObject PyClassMethod_Type;
extern PyTypeObject PyStaticMethod_Type;

extern PyObject * PyClassMethod_New(PyObject *);
extern PyObject * PyStaticMethod_New(PyObject *);


}
#line 91 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/classobject.h"

 

 




extern "C" {


typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    PyObject	*cl_bases;	 
    PyObject	*cl_dict;	 
    PyObject	*cl_name;	 
     
    PyObject	*cl_getattr;
    PyObject	*cl_setattr;
    PyObject	*cl_delattr;
} PyClassObject;

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    PyClassObject *in_class;	 
    PyObject	  *in_dict;	 
    PyObject	  *in_weakreflist;  
} PyInstanceObject;

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    PyObject *im_func;    
    PyObject *im_self;    
    PyObject *im_class;   
    PyObject *im_weakreflist;  
} PyMethodObject;

extern PyTypeObject PyClass_Type, PyInstance_Type, PyMethod_Type;





extern PyObject * PyClass_New(PyObject *, PyObject *, PyObject *);
extern PyObject * PyInstance_New(PyObject *, PyObject *,
                                            PyObject *);
extern PyObject * PyInstance_NewRaw(PyObject *, PyObject *);
extern PyObject * PyMethod_New(PyObject *, PyObject *, PyObject *);

extern PyObject * PyMethod_Function(PyObject *);
extern PyObject * PyMethod_Self(PyObject *);
extern PyObject * PyMethod_Class(PyObject *);


 
#line 62 "/usr/local_cci/Python-2.2.1t/include/python2.2/classobject.h"

extern int PyClass_IsSubclass(PyObject *, PyObject *);



}
#line 92 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/fileobject.h"

 




extern "C" {


extern PyTypeObject PyFile_Type;




extern PyObject * PyFile_FromString(char *, char *);
extern void PyFile_SetBufSize(PyObject *, int);
extern PyObject * PyFile_FromFile(FILE *, char *, char *,
                                             int (*)(FILE *));
extern FILE * PyFile_AsFile(PyObject *);
extern PyObject * PyFile_Name(PyObject *);
extern PyObject * PyFile_GetLine(PyObject *, int);
extern int PyFile_WriteObject(PyObject *, PyObject *, int);
extern int PyFile_SoftSpace(PyObject *, int);
extern int PyFile_WriteString(const char *, PyObject *);
extern int PyObject_AsFileDescriptor(PyObject *);



 
extern const char * Py_FileSystemDefaultEncoding;


}
#line 93 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/cobject.h"








 




extern "C" {


extern PyTypeObject PyCObject_Type;








 
extern PyObject *
PyCObject_FromVoidPtr(void *cobj, void (*destruct)(void*));






 
extern PyObject *
PyCObject_FromVoidPtrAndDesc(void *cobj, void *desc,
                             void (*destruct)(void*,void*));

 
extern void *
PyCObject_AsVoidPtr(PyObject *);

 
extern void *
PyCObject_GetDesc(PyObject *);

 
extern void *
PyCObject_Import(char *module_name, char *cobject_name);


}
#line 94 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/traceback.h"




extern "C" {


 

struct _frame;

int PyTraceBack_Here(struct _frame *);
int PyTraceBack_Print(PyObject *, PyObject *);

 
extern PyTypeObject PyTraceBack_Type;



}
#line 95 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/sliceobject.h"



extern "C" {


 

extern PyObject _Py_EllipsisObject;  



 






 

typedef struct {
    int ob_refcnt; struct _typeobject *ob_type;
    PyObject *start, *stop, *step;
} PySliceObject;

extern PyTypeObject PySlice_Type;



PyObject * PySlice_New(PyObject* start, PyObject* stop,
                                  PyObject* step);
int PySlice_GetIndices(PySliceObject *r, int length,
                                  int *start, int *stop, int *step);


}
#line 96 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/cellobject.h"
 




extern "C" {


typedef struct {
	int ob_refcnt; struct _typeobject *ob_type;
	PyObject *ob_ref;
} PyCellObject;

extern PyTypeObject PyCell_Type;



extern PyObject * PyCell_New(PyObject *);
extern PyObject * PyCell_Get(PyObject *);
extern int PyCell_Set(PyObject *, PyObject *);





}
#line 97 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
extern "C" { 
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/iterobject.h"
 

extern PyTypeObject PySeqIter_Type;



extern PyObject * PySeqIter_New(PyObject *);

extern PyTypeObject PyCallIter_Type;



extern PyObject * PyCallIter_New(PyObject *, PyObject *);
#line 99 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/descrobject.h"
 

typedef PyObject *(*getter)(PyObject *, void *);
typedef int (*setter)(PyObject *, PyObject *, void *);

typedef struct PyGetSetDef {
	char *name;
	getter get;
	setter set;
	char *doc;
	void *closure;
} PyGetSetDef;

typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
				 void *wrapped);

typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
				      void *wrapped, PyObject *kwds);

struct wrapperbase {
	char *name;
	int offset;
	void *function;
	wrapperfunc wrapper;
	char *doc;
	int flags;
	PyObject *name_strobj;
};

 


 






typedef struct {
	int ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
} PyDescrObject;

typedef struct {
	int ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
	PyMethodDef *d_method;
} PyMethodDescrObject;

typedef struct {
	int ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
	struct PyMemberDef *d_member;
} PyMemberDescrObject;

typedef struct {
	int ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
	PyGetSetDef *d_getset;
} PyGetSetDescrObject;

typedef struct {
	int ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
	struct wrapperbase *d_base;
	void *d_wrapped;  
} PyWrapperDescrObject;

extern PyTypeObject PyWrapperDescr_Type;

extern PyObject * PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
extern PyObject * PyDescr_NewMember(PyTypeObject *,
					       struct PyMemberDef *);
extern PyObject * PyDescr_NewGetSet(PyTypeObject *,
					       struct PyGetSetDef *);
extern PyObject * PyDescr_NewWrapper(PyTypeObject *,
						struct wrapperbase *, void *);
extern int PyDescr_IsData(PyObject *);

extern PyObject * PyDictProxy_New(PyObject *);
extern PyObject * PyWrapper_New(PyObject *, PyObject *);


extern PyTypeObject PyProperty_Type;
#line 100 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
} 
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/weakrefobject.h"
 




extern "C" {



typedef struct _PyWeakReference PyWeakReference;

struct _PyWeakReference {
    int ob_refcnt; struct _typeobject *ob_type;
    PyObject *wr_object;
    PyObject *wr_callback;
    long hash;
    PyWeakReference *wr_prev;
    PyWeakReference *wr_next;
};

extern PyTypeObject _PyWeakref_RefType;
extern PyTypeObject _PyWeakref_ProxyType;
extern PyTypeObject _PyWeakref_CallableProxyType;

#line 32 "/usr/local_cci/Python-2.2.1t/include/python2.2/weakrefobject.h"


extern PyObject * PyWeakref_NewRef(PyObject *ob,
                                              PyObject *callback);
extern PyObject * PyWeakref_NewProxy(PyObject *ob,
                                                PyObject *callback);
extern PyObject * PyWeakref_GetObject(PyObject *ref);

extern long _PyWeakref_GetWeakrefCount(PyWeakReference *head);





}
#line 102 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/codecs.h"



extern "C" {











 







 

extern int PyCodec_Register(
       PyObject *search_function
       );

















 

extern PyObject * _PyCodec_Lookup(
       const char *encoding
       );









 

extern PyObject * PyCodec_Encode(
       PyObject *object,
       const char *encoding,
       const char *errors
       );









 

extern PyObject * PyCodec_Decode(
       PyObject *object,
       const char *encoding,
       const char *errors
       );







 

 

extern PyObject * PyCodec_Encoder(
       const char *encoding
       );

 

extern PyObject * PyCodec_Decoder(
       const char *encoding
       );

 

extern PyObject * PyCodec_StreamReader(
       const char *encoding,
       PyObject *stream,
       const char *errors
       );

 

extern PyObject * PyCodec_StreamWriter(
       const char *encoding,
       PyObject *stream,
       const char *errors
       );


}
#line 104 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyerrors.h"



extern "C" {



 

void PyErr_SetNone(PyObject *);
void PyErr_SetObject(PyObject *, PyObject *);
void PyErr_SetString(PyObject *, const char *);
PyObject * PyErr_Occurred(void);
void PyErr_Clear(void);
void PyErr_Fetch(PyObject **, PyObject **, PyObject **);
void PyErr_Restore(PyObject *, PyObject *, PyObject *);

 
int PyErr_GivenExceptionMatches(PyObject *, PyObject *);
int PyErr_ExceptionMatches(PyObject *);
void PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);


 

extern PyObject * PyExc_Exception;
extern PyObject * PyExc_StopIteration;
extern PyObject * PyExc_StandardError;
extern PyObject * PyExc_ArithmeticError;
extern PyObject * PyExc_LookupError;

extern PyObject * PyExc_AssertionError;
extern PyObject * PyExc_AttributeError;
extern PyObject * PyExc_EOFError;
extern PyObject * PyExc_FloatingPointError;
extern PyObject * PyExc_EnvironmentError;
extern PyObject * PyExc_IOError;
extern PyObject * PyExc_OSError;
extern PyObject * PyExc_ImportError;
extern PyObject * PyExc_IndexError;
extern PyObject * PyExc_KeyError;
extern PyObject * PyExc_KeyboardInterrupt;
extern PyObject * PyExc_MemoryError;
extern PyObject * PyExc_NameError;
extern PyObject * PyExc_OverflowError;
extern PyObject * PyExc_RuntimeError;
extern PyObject * PyExc_NotImplementedError;
extern PyObject * PyExc_SyntaxError;
extern PyObject * PyExc_IndentationError;
extern PyObject * PyExc_TabError;
extern PyObject * PyExc_ReferenceError;
extern PyObject * PyExc_SystemError;
extern PyObject * PyExc_SystemExit;
extern PyObject * PyExc_TypeError;
extern PyObject * PyExc_UnboundLocalError;
extern PyObject * PyExc_UnicodeError;
extern PyObject * PyExc_ValueError;
extern PyObject * PyExc_ZeroDivisionError;




extern PyObject * PyExc_MemoryErrorInst;

 
extern PyObject * PyExc_Warning;
extern PyObject * PyExc_UserWarning;
extern PyObject * PyExc_DeprecationWarning;
extern PyObject * PyExc_SyntaxWarning;
extern PyObject * PyExc_OverflowWarning;
extern PyObject * PyExc_RuntimeWarning;


 

extern int PyErr_BadArgument(void);
extern PyObject * PyErr_NoMemory(void);
extern PyObject * PyErr_SetFromErrno(PyObject *);
extern PyObject * PyErr_SetFromErrnoWithFilename(PyObject *, char *);
extern PyObject * PyErr_Format(PyObject *, const char *, ...)
			;





 
extern void PyErr_BadInternalCall(void);
extern void _PyErr_BadInternalCall(char *filename, int lineno);

 


 
PyObject * PyErr_NewException(char *name, PyObject *base,
                                         PyObject *dict);
extern void PyErr_WriteUnraisable(PyObject *);

 
extern int PyErr_Warn(PyObject *, char *);
extern int PyErr_WarnExplicit(PyObject *, char *,
					 char *, int, char *, PyObject *);

 
extern int PyErr_CheckSignals(void);
extern void PyErr_SetInterrupt(void);

 
extern void PyErr_SyntaxLocation(char *, int);
extern PyObject * PyErr_ProgramText(char *, int);








 






#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"










 





#line 51 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"


using std::va_list;




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 127 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyerrors.h"
extern int PyOS_snprintf(char *str, size_t size, const char  *format, ...)
			;
extern int PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
			;


}
#line 105 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pystate.h"

 





extern "C" {


 

struct _ts;  
struct _is;  

typedef struct _is {

    struct _is *next;
    struct _ts *tstate_head;

    PyObject *modules;
    PyObject *sysdict;
    PyObject *builtins;

    int checkinterval;

    int dlopenflags;


} PyInterpreterState;


 

struct _frame;  

 
typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *);

 





typedef struct _ts {

    struct _ts *next;
    PyInterpreterState *interp;

    struct _frame *frame;
    int recursion_depth;
    int ticker;
    int tracing;
    int use_tracing;

    Py_tracefunc c_profilefunc;
    Py_tracefunc c_tracefunc;
    PyObject *c_profileobj;
    PyObject *c_traceobj;

    PyObject *curexc_type;
    PyObject *curexc_value;
    PyObject *curexc_traceback;

    PyObject *exc_type;
    PyObject *exc_value;
    PyObject *exc_traceback;

    PyObject *dict;

     

} PyThreadState;


PyInterpreterState * PyInterpreterState_New(void);
void PyInterpreterState_Clear(PyInterpreterState *);
void PyInterpreterState_Delete(PyInterpreterState *);

PyThreadState * PyThreadState_New(PyInterpreterState *);
void PyThreadState_Clear(PyThreadState *);
void PyThreadState_Delete(PyThreadState *);

void PyThreadState_DeleteCurrent(void);


PyThreadState * PyThreadState_Get(void);
PyThreadState * PyThreadState_Swap(PyThreadState *);
PyObject * PyThreadState_GetDict(void);


 

extern PyThreadState * _PyThreadState_Current;








 
PyInterpreterState * PyInterpreterState_Head(void);
PyInterpreterState * PyInterpreterState_Next(PyInterpreterState *);
PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *);
PyThreadState * PyThreadState_Next(PyThreadState *);


}
#line 107 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/modsupport.h"




extern "C" {


 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"










 





#line 51 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"


using std::va_list;




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 11 "/usr/local_cci/Python-2.2.1t/include/python2.2/modsupport.h"

extern int PyArg_Parse(PyObject *, char *, ...);
extern int PyArg_ParseTuple(PyObject *, char *, ...);
extern int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
                                                  char *, char **, ...);
extern int PyArg_UnpackTuple(PyObject *, char *, int, int, ...);
extern PyObject * Py_BuildValue(char *, ...);

extern int PyArg_VaParse(PyObject *, char *, va_list);
extern PyObject * Py_VaBuildValue(char *, va_list);

extern int PyModule_AddObject(PyObject *, char *, PyObject *);
extern int PyModule_AddIntConstant(PyObject *, char *, long);
extern int PyModule_AddStringConstant(PyObject *, char *, char *);








































 

#line 73 "/usr/local_cci/Python-2.2.1t/include/python2.2/modsupport.h"

#line 80 "/usr/local_cci/Python-2.2.1t/include/python2.2/modsupport.h"

extern PyObject * Py_InitModule4(char *name, PyMethodDef *methods,
                                            char *doc, PyObject *self,
                                            int apiver);









extern char * _Py_PackageContext;


}
#line 109 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pythonrun.h"

 




extern "C" {





typedef struct {
	int cf_flags;   
} PyCompilerFlags;

void Py_SetProgramName(char *);
char * Py_GetProgramName(void);

void Py_SetPythonHome(char *);
char * Py_GetPythonHome(void);

void Py_Initialize(void);
void Py_Finalize(void);
int Py_IsInitialized(void);
PyThreadState * Py_NewInterpreter(void);
void Py_EndInterpreter(PyThreadState *);

int PyRun_AnyFile(FILE *, char *);
int PyRun_AnyFileEx(FILE *, char *, int);

int PyRun_AnyFileFlags(FILE *, char *, PyCompilerFlags *);
int PyRun_AnyFileExFlags(FILE *, char *, int, PyCompilerFlags *);

int PyRun_SimpleString(char *);
int PyRun_SimpleStringFlags(char *, PyCompilerFlags *);
int PyRun_SimpleFile(FILE *, char *);
int PyRun_SimpleFileEx(FILE *, char *, int);
int PyRun_SimpleFileExFlags(FILE *, char *, int, PyCompilerFlags *);
int PyRun_InteractiveOne(FILE *, char *);
int PyRun_InteractiveOneFlags(FILE *, char *, PyCompilerFlags *);
int PyRun_InteractiveLoop(FILE *, char *);
int PyRun_InteractiveLoopFlags(FILE *, char *, PyCompilerFlags *);

struct _node * PyParser_SimpleParseString(char *, int);
struct _node * PyParser_SimpleParseFile(FILE *, char *, int);
struct _node * PyParser_SimpleParseStringFlags(char *, int, int);
struct _node * PyParser_SimpleParseFileFlags(FILE *, char *,
							int, int);

PyObject * PyRun_String(char *, int, PyObject *, PyObject *);
PyObject * PyRun_File(FILE *, char *, int, PyObject *, PyObject *);
PyObject * PyRun_FileEx(FILE *, char *, int,
				   PyObject *, PyObject *, int);
PyObject * PyRun_StringFlags(char *, int, PyObject *, PyObject *,
					PyCompilerFlags *);
PyObject * PyRun_FileFlags(FILE *, char *, int, PyObject *, 
				      PyObject *, PyCompilerFlags *);
PyObject * PyRun_FileExFlags(FILE *, char *, int, PyObject *, 
					PyObject *, int, PyCompilerFlags *);

PyObject * Py_CompileString(char *, char *, int);
PyObject * Py_CompileStringFlags(char *, char *, int,
					    PyCompilerFlags *);
struct symtable * Py_SymtableString(char *, char *, int);

void PyErr_Print(void);
void PyErr_PrintEx(int);
void PyErr_Display(PyObject *, PyObject *, PyObject *);

int Py_AtExit(void (*func)(void));

void Py_Exit(int);

int Py_FdIsInteractive(FILE *, char *);

 
char * Py_GetProgramFullPath(void);
char * Py_GetPrefix(void);
char * Py_GetExecPrefix(void);
char * Py_GetPath(void);

 
const char * Py_GetVersion(void);
const char * Py_GetPlatform(void);
const char * Py_GetCopyright(void);
const char * Py_GetCompiler(void);
const char * Py_GetBuildInfo(void);

 
PyObject * _PyBuiltin_Init(void);
PyObject * _PySys_Init(void);
void _PyImport_Init(void);
void _PyExc_Init(void);

 
void _PyExc_Fini(void);
void _PyImport_Fini(void);
void PyMethod_Fini(void);
void PyFrame_Fini(void);
void PyCFunction_Fini(void);
void PyTuple_Fini(void);
void PyString_Fini(void);
void PyInt_Fini(void);
void PyFloat_Fini(void);
void PyOS_FiniInterrupts(void);

 
char * PyOS_Readline(char *);
extern int (*PyOS_InputHook)(void);
extern char *(*PyOS_ReadlineFunctionPointer)(char *);



 












 
typedef void (*PyOS_sighandler_t)(int);
PyOS_sighandler_t PyOS_getsig(int);
PyOS_sighandler_t PyOS_setsig(int, PyOS_sighandler_t);



}
#line 110 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/ceval.h"



extern "C" {



 

PyObject * PyEval_CallObjectWithKeywords
	(PyObject *, PyObject *, PyObject *);

 

PyObject * PyEval_CallObject(PyObject *, PyObject *);

 



PyObject * PyEval_CallFunction(PyObject *obj, char *format, ...);
PyObject * PyEval_CallMethod(PyObject *obj,
                                        char *methodname, char *format, ...);

void PyEval_SetProfile(Py_tracefunc, PyObject *);
void PyEval_SetTrace(Py_tracefunc, PyObject *);

PyObject * PyEval_GetBuiltins(void);
PyObject * PyEval_GetGlobals(void);
PyObject * PyEval_GetLocals(void);
PyObject * PyEval_GetOwner(void);
PyObject * PyEval_GetFrame(void);
int PyEval_GetRestricted(void);



 
int PyEval_MergeCompilerFlags(PyCompilerFlags *cf);

int Py_FlushLine(void);

int Py_AddPendingCall(int (*func)(void *), void *arg);
int Py_MakePendingCalls(void);

void Py_SetRecursionLimit(int);
int Py_GetRecursionLimit(void);

char * PyEval_GetFuncName(PyObject *);
char * PyEval_GetFuncDesc(PyObject *);












































 

extern PyThreadState * PyEval_SaveThread(void);
extern void PyEval_RestoreThread(PyThreadState *);



extern void PyEval_InitThreads(void);
extern void PyEval_AcquireLock(void);
extern void PyEval_ReleaseLock(void);
extern void PyEval_AcquireThread(PyThreadState *tstate);
extern void PyEval_ReleaseThread(PyThreadState *tstate);
extern void PyEval_ReInitThreads(void);

#line 115 "/usr/local_cci/Python-2.2.1t/include/python2.2/ceval.h"

#line 124 "/usr/local_cci/Python-2.2.1t/include/python2.2/ceval.h"

extern int _PyEval_SliceIndex(PyObject *, int *);



}
#line 111 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/sysmodule.h"

 




extern "C" {


PyObject * PySys_GetObject(char *);
int PySys_SetObject(char *, PyObject *);
FILE * PySys_GetFile(char *, FILE *);
void PySys_SetArgv(int, char **);
void PySys_SetPath(char *);

void PySys_WriteStdout(const char *format, ...)
			;
void PySys_WriteStderr(const char *format, ...)
			;

extern PyObject * _PySys_TraceFunc, *_PySys_ProfileFunc;
extern int _PySys_CheckInterval;

void PySys_ResetWarnOptions(void);
void PySys_AddWarnOption(char *);


}
#line 112 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/intrcheck.h"




extern "C" {


extern int PyOS_InterruptOccurred(void);
extern void PyOS_InitInterrupts(void);
void PyOS_AfterFork(void);


}
#line 113 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"
#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/import.h"

 




extern "C" {


long PyImport_GetMagicNumber(void);
PyObject * PyImport_ExecCodeModule(char *name, PyObject *co);
PyObject * PyImport_ExecCodeModuleEx(
	char *name, PyObject *co, char *pathname);
PyObject * PyImport_GetModuleDict(void);
PyObject * PyImport_AddModule(char *name);
PyObject * PyImport_ImportModule(char *name);
PyObject * PyImport_ImportModuleEx(
	char *name, PyObject *globals, PyObject *locals, PyObject *fromlist);
PyObject * PyImport_Import(PyObject *name);
PyObject * PyImport_ReloadModule(PyObject *m);
void PyImport_Cleanup(void);
int PyImport_ImportFrozenModule(char *);

extern PyObject *_PyImport_FindExtension(char *, char *);
extern PyObject *_PyImport_FixupExtension(char *, char *);

struct _inittab {
    char *name;
    void (*initfunc)(void);
};

extern struct _inittab * PyImport_Inittab;

extern int PyImport_AppendInittab(char *name, void (*initfunc)(void));
extern int PyImport_ExtendInittab(struct _inittab *newtab);

struct _frozen {
    char *name;
    unsigned char *code;
    int size;
};


 

extern struct _frozen * PyImport_FrozenModules;


}
#line 114 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"

#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/abstract.h"



extern "C" {


 



















































































































 

 

     









 

     









 

     







 

     









 

     







 


     







 

     







 

     







 


     







 


     int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result);

       






 

     









 

     









 

     










 

     









 

     int PyCallable_Check(PyObject *o);

       





 



     PyObject * PyObject_Call(PyObject *callable_object,
					 PyObject *args, PyObject *kw);

       




 
     
     PyObject * PyObject_CallObject(PyObject *callable_object,
                                               PyObject *args);

       






 

     PyObject * PyObject_CallFunction(PyObject *callable_object,
                                                 char *format, ...);

       







 


     PyObject * PyObject_CallMethod(PyObject *o, char *m,
                                               char *format, ...);

       






 


     PyObject * PyObject_CallFunctionObjArgs(PyObject *callable,
                                                        ...);

       






 


     PyObject * PyObject_CallMethodObjArgs(PyObject *o,
                                                      PyObject *m, ...);

       





 


     







 


     









 

     









 

     PyObject * PyObject_Type(PyObject *o);

       



 

     int PyObject_Size(PyObject *o);

       





 

        

     int PyObject_Length(PyObject *o);



     PyObject * PyObject_GetItem(PyObject *o, PyObject *key);

       




 

     int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);

       



 

     int PyObject_DelItemString(PyObject *o, char *key);

       



 

     int PyObject_DelItem(PyObject *o, PyObject *key);

       


 

     int PyObject_AsCharBuffer(PyObject *obj,
					  const char **buffer,
					  int *buffer_len);

       









 

     int PyObject_CheckReadBuffer(PyObject *obj);

      




 

     int PyObject_AsReadBuffer(PyObject *obj,
					  const void **buffer,
					  int *buffer_len);

       









 

     int PyObject_AsWriteBuffer(PyObject *obj,
					   void **buffer,
					   int *buffer_len);

       








 

 

     PyObject * PyObject_GetIter(PyObject *);
     

 





     PyObject * PyIter_Next(PyObject *);
     


 

 

     int PyNumber_Check(PyObject *o);

       





 

     PyObject * PyNumber_Add(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_Subtract(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_Multiply(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Divide(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_FloorDivide(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_TrueDivide(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Remainder(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Divmod(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Power(PyObject *o1, PyObject *o2,
                                          PyObject *o3);

       




 

     PyObject * PyNumber_Negative(PyObject *o);

       



 

     PyObject * PyNumber_Positive(PyObject *o);

       



 

     PyObject * PyNumber_Absolute(PyObject *o);

       



 

     PyObject * PyNumber_Invert(PyObject *o);

       





 

     PyObject * PyNumber_Lshift(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Rshift(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_And(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Xor(PyObject *o1, PyObject *o2);

       





 

     PyObject * PyNumber_Or(PyObject *o1, PyObject *o2);

       




 

     
















 

     PyObject * PyNumber_Int(PyObject *o);

       




 

     PyObject * PyNumber_Long(PyObject *o);

       




 

     PyObject * PyNumber_Float(PyObject *o);

       



 
	 
 

     PyObject * PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceDivide(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceFloorDivide(PyObject *o1,
						       PyObject *o2);

       





 

     PyObject * PyNumber_InPlaceTrueDivide(PyObject *o1,
						      PyObject *o2);

       





 

     PyObject * PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
     						 PyObject *o3);

       




 

     PyObject * PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);

       




 

     PyObject * PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);

       




 


 

     int PySequence_Check(PyObject *o);

       





 

     int PySequence_Size(PyObject *o);

       


 

        

     int PySequence_Length(PyObject *o);



     PyObject * PySequence_Concat(PyObject *o1, PyObject *o2);

       




 

     PyObject * PySequence_Repeat(PyObject *o, int count);

       




 

     PyObject * PySequence_GetItem(PyObject *o, int i);

       


 

     PyObject * PySequence_GetSlice(PyObject *o, int i1, int i2);

       




 

     int PySequence_SetItem(PyObject *o, int i, PyObject *v);

       




 

     int PySequence_DelItem(PyObject *o, int i);

       



 

     int PySequence_SetSlice(PyObject *o, int i1, int i2,
                                        PyObject *v);

       



 

     int PySequence_DelSlice(PyObject *o, int i1, int i2);

       



 

     PyObject * PySequence_Tuple(PyObject *o);

       


 


     PyObject * PySequence_List(PyObject *o);
       


 

     PyObject * PySequence_Fast(PyObject *o, const char* m);
       






 



       


 



       


 

     int PySequence_Count(PyObject *o, PyObject *value);

       




 

     int PySequence_Contains(PyObject *seq, PyObject *ob);
       


 




     int _PySequence_IterSearch(PyObject *seq, PyObject *obj,
     		    int operation);
	








 

 

     int PySequence_In(PyObject *o, PyObject *value);

 


       



 

     int PySequence_Index(PyObject *o, PyObject *value);

       



 

 

     PyObject * PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);

       




 

     PyObject * PySequence_InPlaceRepeat(PyObject *o, int count);

       




 

 

     int PyMapping_Check(PyObject *o);

       




 

     int PyMapping_Size(PyObject *o);

       



 

        

     int PyMapping_Length(PyObject *o);



     






 


     






 


     int PyMapping_HasKeyString(PyObject *o, char *key);

       





 

     int PyMapping_HasKey(PyObject *o, PyObject *key);

       






 

     






 


     






 


     








 


     PyObject * PyMapping_GetItemString(PyObject *o, char *key);

       



 

     int PyMapping_SetItemString(PyObject *o, char *key,
                                            PyObject *value);

       



 


int PyObject_IsInstance(PyObject *object, PyObject *typeorclass);
       

int PyObject_IsSubclass(PyObject *object, PyObject *typeorclass);
       



}
#line 116 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"




 
 






#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyfpe.h"



extern "C" {





































 



















































































 

#line 167 "/usr/local_cci/Python-2.2.1t/include/python2.2/pyfpe.h"







}
#line 129 "/net/cci/rwgk/dist/boost/boost/python/detail/python22_fixed.h"


 




#line 120 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

































#line 9 "/net/cci/rwgk/dist/boost/boost/python/converter/to_python_function_type.hpp"

namespace boost { namespace python { namespace converter { 




typedef PyObject* (*to_python_function_t)(void const*);



template <class T, class ToPython>
struct as_to_python_function
{
    static PyObject* convert(void const* x)
    {
        return ToPython::convert(*(T const*)x);
    }
};

}}} 

#line 9 "/net/cci/rwgk/dist/boost/boost/python/converter/arg_to_python_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/converter/arg_to_python_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/same_traits.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_same.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/config.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/config.hpp"
























#line 1 "/net/cci/rwgk/dist/boost/boost/config/user.hpp"




































































#line 27 "/net/cci/rwgk/dist/boost/boost/config.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/config/select_compiler_config.hpp"












#line 30 "/net/cci/rwgk/dist/boost/boost/config/select_compiler_config.hpp"



#line 78 "/net/cci/rwgk/dist/boost/boost/config/select_compiler_config.hpp"

#line 32 "/net/cci/rwgk/dist/boost/boost/config.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/config/compiler/compaq_cxx.hpp"











#line 1 "/net/cci/rwgk/dist/boost/boost/config/compiler/common_edg.hpp"
















































#line 13 "/net/cci/rwgk/dist/boost/boost/config/compiler/compaq_cxx.hpp"






#line 36 "/net/cci/rwgk/dist/boost/boost/config.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/config/select_stdlib_config.hpp"

















#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/utility"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/utility"



































































 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"




















































 







 

#line 72 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"
#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










#line 90 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"


















 



 









 

 
 



 













 






 
 



 

 


 

 


 





 

 


 




 


 







 




 






 

 

 






 

 




 

 






 

 




 





 



 




 

 





 

 




 

 




 

 




 

 

 




 

#line 302 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"
 













 




 





 


#line 338 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"
 




















 

 







 

 

 



 

 


 






 




 






 

 







 

 






 

 






 

 



 

 




 

 




 

 



 

 


 




 

 





 

 





 

 




 

 




 

 




 

 





 

 




 

 




 

 



 

 







 

 








 

 







 

 




 

 




 

 




 

 




 

 




 

 




 

 




 

 





 

 




 

 




 

 





 

 




 

 




 

 




 

 




 

 




 

 




 

 




 

 




 

 





 

 




 

 




 

 




 

 




 

 




 

 





 

 




 

 




 

 




 











 

 




 

 




 

 





 

 




 

 




 

 





 

 




 

 



 

 



 






 






 

 



 

 



 

 



 

 



 

 




  
 



  

 





 

 



 

 



 

 



 

 




 

 



 

 



 

 



 

 



 

 



 

 



 

 




 

 



 





 




 

 



 

 



 

 





 

#line 1014 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"

#line 1021 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"


#line 1038 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"









 

 

 









 







 

#line 1174 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"

 

#line 1232 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"


 

#line 1275 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"




 
 
 
 
 



 
 



 
 
 
 






 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 



 
 
 
 



 
 
 
 
 
 






 
 


 
 











 
 
 
 



 







 
 




 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 





 
 
 
 
 
 




 
 
 
 
 
 
 
 
 
 
 
 

 
 

 
 
 
 
 
 
 
 

 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 
 

 
 

 
 
 
 

 
 
 
 
 
 
 
 
 
 




 
 
 
 
 
 
 
 



 
 


 

#line 1562 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"










 

 








 









 





 














 






 


#line 1638 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"
























































#line 1711 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"




#line 1727 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"






#line 1744 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"





















#line 1772 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"
 


#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/compnent.hxx"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/compnent.hxx"























































 

















#line 81 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/compnent.hxx"





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 1779 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"














#line 1828 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"



#line 1838 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"



























#line 1875 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdcomp"




















#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 71 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/utility"



#      pragma __environment __save
#      pragma __environment __cxx_header_defaults









namespace std {



  namespace rel_ops {






    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);
    }


  }  






  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)
    { ; }

    template <class U, class V> pair(const pair<U,V>& p) 
      : first(p.first), second(p.second)
    { ; }


    ~pair () {;} 
  };

  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(T1 x, T2 y)



  {
    return pair<T1, T2>(x, y);
  }


}








#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 19 "/net/cci/rwgk/dist/boost/boost/config/select_stdlib_config.hpp"

#line 31 "/net/cci/rwgk/dist/boost/boost/config/select_stdlib_config.hpp"



#line 64 "/net/cci/rwgk/dist/boost/boost/config/select_stdlib_config.hpp"


#line 41 "/net/cci/rwgk/dist/boost/boost/config.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/config/stdlib/roguewave.hpp"









#line 16 "/net/cci/rwgk/dist/boost/boost/config/stdlib/roguewave.hpp"



#line 26 "/net/cci/rwgk/dist/boost/boost/config/stdlib/roguewave.hpp"









































#line 73 "/net/cci/rwgk/dist/boost/boost/config/stdlib/roguewave.hpp"










































#line 45 "/net/cci/rwgk/dist/boost/boost/config.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/config/select_platform_config.hpp"














#line 60 "/net/cci/rwgk/dist/boost/boost/config/select_platform_config.hpp"






   





#line 1 "/net/cci/rwgk/dist/boost/boost/config/posix_features.hpp"












      




      




      




      
      
      
      
      
      




      
      





      
      
      
      




      
      
      






      
      
      
      





#line 73 "/net/cci/rwgk/dist/boost/boost/config/select_platform_config.hpp"












#line 50 "/net/cci/rwgk/dist/boost/boost/config.hpp"







#line 1 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"





























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 31 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"
#line 39 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"




























#line 73 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"

















































































































































































#line 264 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"
























#line 299 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"




























































#line 373 "/net/cci/rwgk/dist/boost/boost/config/suffix.hpp"




#line 58 "/net/cci/rwgk/dist/boost/boost/config.hpp"












#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/config.hpp"




















#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/is_same.hpp"






#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/template_arity_fwd.hpp"



















namespace boost {
namespace mpl {
namespace aux {

template< typename F > struct template_arity;

} 
} 
} 

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/params.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/preprocessor.hpp"





























#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/params.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 30 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/params.hpp"





#line 45 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/params.hpp"

#line 67 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/params.hpp"

#line 21 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/lambda_support.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/lambda.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/ttp.hpp"


























#line 33 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/ttp.hpp"

#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/lambda.hpp"














#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/lambda_support.hpp"





#line 57 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/lambda_support.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/overload_resolution.hpp"



























#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"


#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/bool_c.hpp"





















namespace boost {
namespace mpl {

template< bool C > struct bool_c
{
    static const bool value = C;
    typedef bool_c type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};


typedef bool_c<true> true_c;
typedef bool_c<false> false_c;

} 
} 

#line 21 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"



#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/is_same.hpp"

namespace boost {



template< typename T, typename U > struct is_same : mpl::bool_c< false > {   }; 
template< typename T > struct is_same< T,T > : mpl::bool_c< true > {   };






#line 87 "/net/cci/rwgk/dist/boost/boost/type_traits/is_same.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 91 "/net/cci/rwgk/dist/boost/boost/type_traits/is_same.hpp"



#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/same_traits.hpp"

#line 11 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/add_const.hpp"
















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/add_const.hpp"

namespace boost {






#line 33 "/net/cci/rwgk/dist/boost/boost/type_traits/add_const.hpp"

template< typename T > struct add_const { typedef T const type;  }; 






template< typename T > struct add_const<T& > { typedef T& type; };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 47 "/net/cci/rwgk/dist/boost/boost/type_traits/add_const.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/add_volatile.hpp"
















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/add_volatile.hpp"

namespace boost {






#line 33 "/net/cci/rwgk/dist/boost/boost/type_traits/add_volatile.hpp"

template< typename T > struct add_volatile { typedef T volatile type;  }; 






template< typename T > struct add_volatile<T& > { typedef T& type; };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 47 "/net/cci/rwgk/dist/boost/boost/type_traits/add_volatile.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/add_cv.hpp"
















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/add_cv.hpp"

namespace boost {






#line 33 "/net/cci/rwgk/dist/boost/boost/type_traits/add_cv.hpp"

template< typename T > struct add_cv { typedef T const volatile type;  }; 






template< typename T > struct add_cv<T& > { typedef T& type; };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 47 "/net/cci/rwgk/dist/boost/boost/type_traits/add_cv.hpp"

#line 19 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/cv_traits_impl.hpp"

















namespace boost {
namespace detail {



template <typename T> struct cv_traits_imp {};

template <typename T>
struct cv_traits_imp<T*>
{
    static const bool is_const = false;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const T*>
{
    static const bool is_const = true;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<volatile T*>
{
    static const bool is_const = false;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const volatile T*>
{
    static const bool is_const = true;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};

} 
} 



#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"
#line 27 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 30 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"

namespace boost {




template< typename T > struct is_const : mpl::bool_c< ::boost::detail::cv_traits_imp<T* > ::is_const > {   }; 
template< typename T > struct is_const< T& > : mpl::bool_c< false > {  };

#line 48 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"

#line 55 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"

#line 117 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 121 "/net/cci/rwgk/dist/boost/boost/type_traits/is_const.hpp"



#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_volatile.hpp"















#line 24 "/net/cci/rwgk/dist/boost/boost/type_traits/is_volatile.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 27 "/net/cci/rwgk/dist/boost/boost/type_traits/is_volatile.hpp"

namespace boost {




template< typename T > struct is_volatile : mpl::bool_c< ::boost::detail::cv_traits_imp<T* > ::is_volatile > {   }; 
template< typename T > struct is_volatile< T& > : mpl::bool_c< false > {  };

#line 45 "/net/cci/rwgk/dist/boost/boost/type_traits/is_volatile.hpp"

#line 107 "/net/cci/rwgk/dist/boost/boost/type_traits/is_volatile.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/is_volatile.hpp"

#line 21 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_const.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/broken_compiler_spec.hpp"
















#line 85 "/net/cci/rwgk/dist/boost/boost/type_traits/broken_compiler_spec.hpp"























#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_const.hpp"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstddef"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstddef"










 








#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef_cname_impl"










 



extern "C" {
namespace std {

typedef long             ptrdiff_t;

typedef unsigned long   size_t;

}    
}    










#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 22 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstddef"


#line 31 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstddef"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_const.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_const.hpp"

namespace boost {



namespace detail {

template <typename T, bool is_vol>
struct remove_const_helper
{
    typedef T type;
};

template <typename T>
struct remove_const_helper<T, true>
{
    typedef T volatile type;
};


template <typename T>
struct remove_const_impl
{
    typedef typename remove_const_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_volatile<T>::value
        >::type type;
};

} 



template< typename T > struct remove_const { typedef typename detail::remove_const_impl<T> ::type type;  }; 
template< typename T > struct remove_const<T& > { typedef T& type; };
template< typename T, std::size_t N > struct remove_const<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { typedef T volatile type[N]; };







} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 70 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_const.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_volatile.hpp"





















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_volatile.hpp"

namespace boost {



namespace detail {

template <typename T, bool is_const>
struct remove_volatile_helper
{
    typedef T type;
};

template <typename T>
struct remove_volatile_helper<T,true>
{
    typedef T const type;
};

template <typename T>
struct remove_volatile_impl
{
    typedef typename remove_volatile_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_const<T>::value
        >::type type;
};

} 



template< typename T > struct remove_volatile { typedef typename detail::remove_volatile_impl<T> ::type type;  }; 
template< typename T > struct remove_volatile<T& > { typedef T& type; };
template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { typedef T const type[N]; };

#line 66 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_volatile.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 70 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_volatile.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_cv.hpp"




















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_cv.hpp"

namespace boost {




template< typename T > struct remove_cv { typedef typename detail::cv_traits_imp<T* > ::unqualified_type type;  }; 
template< typename T > struct remove_cv<T& > { typedef T& type; };
template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };

#line 40 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_cv.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 44 "/net/cci/rwgk/dist/boost/boost/type_traits/remove_cv.hpp"

#line 24 "/net/cci/rwgk/dist/boost/boost/type_traits/cv_traits.hpp"

#line 12 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type.hpp"









namespace boost {

  
  
  template <class T>
  struct type {};

}

#line 13 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/base_type_traits.hpp"








namespace boost { namespace python { 

namespace detail
{
  struct unspecialized {};
}



template <class T> struct base_type_traits
  : detail::unspecialized
{};

template <>
struct base_type_traits<PyObject>
{
    typedef PyObject type;
};

template <>
struct base_type_traits<PyTypeObject>
{
    typedef PyObject type;
};

}} 

#line 14 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/convertible.hpp"















namespace boost { namespace python { namespace detail { 

typedef char* yes_convertible;
typedef int* no_convertible;

template <class Target>
struct convertible
{

    static inline no_convertible check(...) { return 0; }
    static inline yes_convertible check(Target) { return 0; }
#line 35 "/net/cci/rwgk/dist/boost/boost/python/detail/convertible.hpp"
};

}}} 

#line 15 "/net/cci/rwgk/dist/boost/boost/python/cast.hpp"

namespace boost { namespace python { 

namespace detail
{
  template <class Source, class Target> inline Target* upcast_impl(Source*, Target*);
  
  template <class Source, class Target>
  inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*)
  {
      return p;
  }

  template <class Source, class Target>
  inline Target* upcast(Source* p, no_convertible, no_convertible, Target*)
  {
      typedef typename base_type_traits<Source>::type base;
      
      return detail::upcast_impl((base*)p, (Target*)0);
  }

  template <bool is_same = true>
  struct upcaster
  {
      template <class T>
      static inline T* execute(T* x, T*) { return x; }
  };
  
  template <>
  struct upcaster<false>
  {
      template <class Source, class Target>
      static inline Target* execute(Source* x, Target*)
      {
          return detail::upcast(
              x, detail::convertible<Target*>::check(x)
              , detail::convertible<Source*>::check((Target*)0)
              , (Target*)0);
      }
  };


  template <class Target, class Source>
  inline Target* downcast(Source* p, yes_convertible)
  {
      return static_cast<Target*>(p);
  }

  template <class Target, class Source>
  inline Target* downcast(Source* p, no_convertible, boost::type<Target>* = 0)
  {
      typedef typename base_type_traits<Source>::type base;
      return (Target*)detail::downcast<base>(p, convertible<Source*>::check((base*)0));
  }

  template <class T>
  inline void assert_castable(boost::type<T>* = 0)
  {
      typedef char must_be_a_complete_type[sizeof(T)];
  }

  template <class Source, class Target>
  inline Target* upcast_impl(Source* x, Target*)
  {
      typedef typename add_cv<Source>::type src_t;
      typedef typename add_cv<Target>::type target_t;
      static bool const same = is_same<src_t,target_t>::value;
      
      return detail::upcaster<same>::execute(x, (Target*)0);
  }
}

template <class Target, class Source>
inline Target* upcast(Source* x, Target* = 0)
{
    detail::assert_castable<Source>();
    detail::assert_castable<Target>();
    return detail::upcast_impl(x, (Target*)0);
    
}

template <class Target, class Source>
inline Target* downcast(Source* x, Target* = 0)
{
    detail::assert_castable<Source>();
    detail::assert_castable<Target>();
    return detail::downcast<Target>(x, detail::convertible<Source*>::check((Target*)0));
}

}} 

#line 11 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/errors.hpp"











#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/config.hpp"
















#line 29 "/net/cci/rwgk/dist/boost/boost/python/detail/config.hpp"

#line 45 "/net/cci/rwgk/dist/boost/boost/python/detail/config.hpp"














 














#line 88 "/net/cci/rwgk/dist/boost/boost/python/detail/config.hpp"























#line 13 "/net/cci/rwgk/dist/boost/boost/python/errors.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 14 "/net/cci/rwgk/dist/boost/boost/python/errors.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/function/function0.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/function/detail/maybe_include.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/function/function_template.hpp"

















#line 1 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cassert"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cassert"










 










#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 4 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"




































































 



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstdlib"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstdlib"










 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 75 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"



































































 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stddefs"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stddefs"






















































 




















using std::size_t;
using std::ptrdiff_t;










  




 



    
#line 104 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stddefs"















 











 





#line 172 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stddefs"

 








 
#line 189 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stddefs"

 
#line 198 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stddefs"



const size_t _RWSTD_NPOS            = ~(size_t)0;




















namespace _RWrwstd {

template <bool __b>
struct __rw_select { };

template <>
struct __rw_select<true> { };



}



















#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 72 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"









#      pragma __environment __save
#      pragma __environment __cxx_header_defaults















namespace std {





  
  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() {;}
  };












  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;
  };



  template <class Iterator> struct iterator_traits
  {
    typedef typename Iterator::value_type value_type;
    typedef typename Iterator::difference_type difference_type;
    typedef typename Iterator::pointer pointer;
    typedef typename Iterator::reference reference;
    typedef typename Iterator::iterator_category iterator_category;
  };
  template <class T> struct iterator_traits<T*>
  {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T& reference;
    typedef random_access_iterator_tag iterator_category;
  };
  template <class T> struct iterator_traits<const T*>
  {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
    typedef const T* pointer;
    typedef const T& reference;
    typedef random_access_iterator_tag iterator_category;
  };

  template <class ForwardIterator>
  inline typename iterator_traits<ForwardIterator>::difference_type
  distance (ForwardIterator first, ForwardIterator last)
  {
    typename iterator_traits<ForwardIterator>::difference_type n = 0;
    _RWdistance(first, last, n, 
               iterator_traits<ForwardIterator>::iterator_category());
    return n;
  }

  template <class ForwardIterator, class Distance>
  inline void advance (ForwardIterator& i, Distance n)
  {
    _RWadvance(i, n, 
          iterator_traits<ForwardIterator>::iterator_category());
  }







  template <class T>
  inline random_access_iterator_tag 
  _RWiterator_category (const T*)
  {
    return random_access_iterator_tag();
  }

  template <class Category, class T, class Distance, 
            class Pointer, class Reference> 
  inline Category
  _RWiterator_category (const iterator<Category, T, Distance,Pointer,Reference>&)
  {
    typename iterator<Category, T, Distance,T*,T&>::iterator_category tmp;
    return tmp;
  }


  template <class T> 
  inline typename T::iterator_category
  _RWiterator_category (const T&)
  {
    typename T::iterator_category tmp;
    return tmp;
  }







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

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

  inline bool _RWis_bidirectional_iterator(bidirectional_iterator_tag)
  { return true; }

  inline bool _RWis_bidirectional_iterator(random_access_iterator_tag)
  { return true; }

  inline bool _RWis_random_access_iterator(random_access_iterator_tag)
  { return true; }




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

  template <class T>
  inline T* 
  _RWvalue_type (const T*)
  {
    return static_cast< T* >(0);
  }


  template <class T> 
  inline typename T::value_type*
  _RWvalue_type (const T&)
  {
    return static_cast< typename T::value_type* >(0);
  }





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

  template <class T>
  inline ptrdiff_t* 
  _RWdistance_type (const T*)
  { 
    return static_cast< ptrdiff_t* >(0);
  }



  template <class T>
  inline typename T::difference_type*
  _RWdistance_type(const T&) 
  { 
    return static_cast< typename T::difference_type* >(0);
  }






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

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

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

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

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

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

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

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





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

    _RWdistance(first, last, n, _RWiterator_category(first));



  }


#line 372 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"








#line 389 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"






  template <class Iterator> class reverse_iterator;

  template <class Iterator>
  inline bool operator== (const reverse_iterator<Iterator> & x, 
                          const reverse_iterator<Iterator> & y);

  template <class Iterator>
  inline bool operator< (const reverse_iterator<Iterator> & x, 
                         const reverse_iterator<Iterator> & y);

  template <class Iterator>
  inline 

  typename iterator_traits<Iterator>::difference_type



  operator- (const reverse_iterator<Iterator> & x, 
             const reverse_iterator<Iterator> & y);

  template <class Iterator>
  inline reverse_iterator<Iterator>

  operator+ (typename iterator_traits<Iterator>::difference_type n, 


             const reverse_iterator<Iterator> & x);
#line 436 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"


  template <class Iterator>
  class reverse_iterator
   : public iterator<typename iterator_traits<Iterator>::iterator_category,
            typename iterator_traits<Iterator>::value_type,
            typename iterator_traits<Iterator>::difference_type,           
            typename iterator_traits<Iterator>::pointer,
            typename iterator_traits<Iterator>::reference>
  {
    typedef reverse_iterator<Iterator> self;
  public:
    typedef typename iterator_traits<Iterator>::difference_type difference_type;
    typedef typename iterator_traits<Iterator>::value_type value_type;
    typedef typename iterator_traits<Iterator>::pointer pointer;
    typedef typename iterator_traits<Iterator>::reference reference;
  private:
#line 470 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"


    friend bool std::operator== <Iterator>    (const self& x, const self& y);
    friend bool std::operator<  <Iterator>    (const self& x, const self& y);
    friend difference_type std::operator- <Iterator> (const self& x, const self& y);
    friend self std::operator+ <Iterator>     (difference_type n, const self& x);
#line 482 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"
        
  protected:

    Iterator current;

  public:
    typedef Iterator iterator_type;


    reverse_iterator(): current() {}



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

    template <class U>

    reverse_iterator (const reverse_iterator<U>& x) : current(x.base()) {}




    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>
  inline bool operator== (const reverse_iterator<Iterator> & x, 
                          const reverse_iterator<Iterator> & y)
  {
    return x.current == y.current;
  }

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


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

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

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

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


  template <class Iterator>
  inline 

  typename iterator_traits<Iterator>::difference_type



  operator- (const reverse_iterator<Iterator> & x, 
                             const reverse_iterator<Iterator> & y)
  {
    return y.current - x.current;
  }

  template <class Iterator>
  inline reverse_iterator<Iterator>

  operator+ (typename iterator_traits<Iterator>::difference_type n, 

             const reverse_iterator<Iterator> & x)
#line 600 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"
  {
    return reverse_iterator<Iterator>(x.current - n);
  }


#line 702 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"





  template <class Container>
  class back_insert_iterator 
    : public iterator<output_iterator_tag,

	void, void, void, void>
#line 718 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"
  {
  protected:

    Container* container;

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

    explicit 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;

    explicit front_insert_iterator (Container& x) : container(&x) {}
    front_insert_iterator<Container>&

    operator= (const typename Container::const_reference 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::const_reference 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>;




}




#line 862 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"



namespace std {


#line 1039 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iterator"



}












#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 79 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"



































































  



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstdio"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstdio"










 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 76 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/climits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/climits"










 

#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/climits"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 77 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
#line 84 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"
 


 





 

















#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef.h"










 





#line 30 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef_ansi_impl"










 

using std::ptrdiff_t;
using std::size_t;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stddef.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 29 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/exception"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/exception"




















































 






#      pragma __environment __save
#      pragma __environment __cxx_header_defaults















namespace std {





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

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

extern bool uncaught_exception() throw();








} 




namespace _RWrwstd {


  extern const char * _RWrw_stdexcept_NoNamedException;
  extern const char * _RWrw_stdexcept_BadException;


}










#line 139 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/exception"


namespace std {


  class  exception     
  {
  public:
    exception () throw()
    { ; }
    exception (const exception&) throw() 
    { ; }




    exception& operator= (const exception& e)  throw()
    { return *this; }
    virtual ~exception ()  throw();

    virtual const char * what () const  throw()
    { 
      return _RWrwstd::_RWrw_stdexcept_NoNamedException;
    }
  };




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

    virtual const char * what () const  throw()
    { 
      return _RWrwstd::_RWrw_stdexcept_BadException;
    }
  };





} 





#line 207 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/exception"











#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 30 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"


#   pragma __environment save
#   pragma __environment cxx_header_defaults


#line 42 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/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();
    virtual ~bad_alloc() throw();
    virtual const char* what() const throw();
};



struct nothrow_t { };


const nothrow_t nothrow = {};


}


#line 86 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"



 

void *operator new[](size_t) throw (std::bad_alloc);





 

void operator delete[](void*) throw();





 
void *operator new(size_t, const std::nothrow_t&) throw();




 
#line 118 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"
void operator delete(void* ptr, const std::nothrow_t&) throw();
#line 125 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"



 

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






 
#line 146 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"
void operator delete[](void* ptr, const std::nothrow_t&) throw();
#line 154 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"













#line 191 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"







namespace std {


typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();






}   



#line 220 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"

#line 229 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"



 
void *operator new(size_t) throw (std::bad_alloc);





 


void operator delete(void* ptr) throw();
#line 254 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/new"





 
void *operator new(size_t, void*) throw();



 

void operator delete(void*, void*) throw();





 

void *operator new[](size_t, void*) throw();




 


void operator delete[](void*, void*) throw();










void __cxxl_default_new_handler() throw (std::bad_alloc);








#   pragma __environment restore




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 86 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr"




















































 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"










 





#line 51 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/stdarg.h"


using std::va_list;




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 58 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr_macros"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr_macros"




















































 













#line 87 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr_macros"

         
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 59 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/rwstderr"




#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










namespace _RWrwstd {




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


} 









#      pragma __environment __restore


         


#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 89 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"




























































 




 





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stl_macros"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stl_macros"



















#      pragma __environment __save
#      pragma __environment __cxx_header_defaults








#line 37 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stl_macros"

#line 49 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stl_macros"




extern void __cxx_mutex_lock(void*&);
extern void __cxx_mutex_unlock(void*&);
#line 61 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stl_macros"
extern void __cxx_mutex_create(void*&);

extern void __cxx_mutex_destroy(void*&);







#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 74 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"


#   pragma __environment __save
#   pragma __environment __cxx_header_defaults


typedef void * _RWSTDMutexType;






    extern int _RWcxx_locale_global_is_initialized;
    extern int _RWcxx_locale_id_imp_is_initialized;
#line 126 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"






class _RWSTDMutex
{
  private:

    _RWSTDMutexType mutex;




#line 147 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"

    void init ();



    void allocate_mutex ();
    void deallocate_mutex ();

    
    
    
    _RWSTDMutex (const _RWSTDMutex&);
    _RWSTDMutex& operator= (const _RWSTDMutex&);

public:

  enum StaticCtor { staticCtor };

  _RWSTDMutex ();             
  _RWSTDMutex (StaticCtor);   
  ~_RWSTDMutex ();            

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

class _RWSTDGuard
{
  private:

    _RWSTDMutex& rwmutex;

  public:

    _RWSTDGuard  (_RWSTDMutex& m);  
    ~_RWSTDGuard ();               
};






 

inline _RWSTDMutex::_RWSTDMutex (_RWSTDMutex::StaticCtor)
{
    
    
    
}

inline _RWSTDMutex::~_RWSTDMutex () 
{ 
#line 214 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
    __cxx_mutex_destroy((void*&)mutex);


    deallocate_mutex();
#line 230 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
}


void inline _RWSTDMutex::init ()
{ 
#line 243 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
    __cxx_mutex_create((void*&)mutex);
#line 263 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
}  

inline _RWSTDMutex::_RWSTDMutex () 
{ 


  allocate_mutex();

  init(); 
}  

inline void _RWSTDMutex::acquire ()
{ 
#line 283 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
    if (!mutex) {
	allocate_mutex ();
#line 292 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
	__cxx_mutex_create((void*&)mutex);

    }
#line 302 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
    __cxx_mutex_lock((void*&)mutex);
#line 314 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
}

inline void _RWSTDMutex::release ()
{ 
#line 325 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
    __cxx_mutex_unlock((void*&)mutex);
#line 337 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdmutex"
}


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

inline _RWSTDGuard::~_RWSTDGuard () { rwmutex.release(); }


class _RWSTDlocale_global_Mutex : public _RWSTDMutex
{
public:
    _RWSTDlocale_global_Mutex () {
           _RWcxx_locale_global_is_initialized = 1;
    }
    ~_RWSTDlocale_global_Mutex () {
           _RWcxx_locale_global_is_initialized = 0;
    }
};
class _RWSTDlocale_id_imp_Mutex : public _RWSTDMutex
{
public:
    _RWSTDlocale_id_imp_Mutex () {
           _RWcxx_locale_id_imp_is_initialized = 1;
    }
    ~_RWSTDlocale_id_imp_Mutex () {
           _RWcxx_locale_id_imp_is_initialized = 0;
    }
};














#      pragma __environment __restore
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 92 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"







#line 105 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"











#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










namespace _RWrwstd {





  template <class T , class Base>
  class _RWrw_basis : public Base
  {
    T _RWdata_;
  public:
    _RWrw_basis(const _RWrw_basis& b) : _RWdata_(b._RWdata_) {;}
    _RWrw_basis(const T& t, const Base& b) : Base(b), _RWdata_(t) {;}
    _RWrw_basis(int t, const Base& b) : Base(b), _RWdata_((T)t) {;}   
    _RWrw_basis operator=(const T& t) { _RWdata_ = t; return *this; }
    _RWrw_basis operator=(int t) { _RWdata_ = (T)t; return *this; }   
    _RWrw_basis operator=(const _RWrw_basis& r) 
    { _RWdata_ = r._RWdata_; return *this; }
    _RWrw_basis operator=(const Base& b) 
    { *this = _RWrw_basis<T,Base>(_RWdata_,b); return *this; }
    operator T() { return _RWdata_; }
    T data() const { return _RWdata_; }
  };







  
  
  
  
  
  
  
  
  
  template <class T, class size>
  inline size _RWrw_allocation_size(T*,size cursize, size)
  {
    if (cursize) 
      return cursize*2;
    else

      return (1024)*(1+((sizeof(T)-1)/1024)) / sizeof(T);
#line 182 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
  }
#line 217 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"



#line 230 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"







  template <class T>
  inline void _RWdestroy (T* pointer)
  {
#line 246 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
    pointer->~T();


  }



#pragma message disable uninit


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


#pragma message enable uninit


  template <class ForwardIterator> 
  inline void _RWdestroy (ForwardIterator first, ForwardIterator last)
  {
    while (first != last)
      ++first;
  }


#line 339 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"




  extern const char * rwse_OutOfRange;



} 

namespace std {









  template <class T> class allocator;




  template< >
  class allocator<void> {  
  public:
    typedef void*       pointer;
    typedef const void* const_pointer;
    typedef void        value_type;
   
    template <class U> 
    struct rebind { typedef allocator<U> other; };
    

    ~allocator()  throw()
    { ; }


  };


  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;

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

    allocator()  throw()
    { ; }

    allocator(const allocator&)  throw()
    { ; }

    template <class U>
    allocator(const allocator<U>&)  throw()
    { ; }

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

    ~allocator()  throw()
    { ; }


    pointer address(reference x) const
    { 
      return static_cast< pointer >(&x); 
    }
    const_pointer address(const_reference x) const
    { 
      return static_cast< const_pointer >(&x); 
    }


    pointer allocate(size_type n, allocator<void>::const_pointer = 0)



    { 
      pointer tmp =
      static_cast< pointer >((::operator new(static_cast< size_t >((n * sizeof(value_type))))));

      if (tmp == 0) throw bad_alloc();
      return tmp;
    }

    void deallocate(pointer p, size_type) 
    { 

      if ( p )

      ::operator delete(p);
    }
    size_type max_size() const  throw()
    { 

      return 1 > 4294967295U/sizeof(T) ? size_type(1) : size_type(4294967295U/sizeof(T
));



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

    inline void destroy(T* p);

  };



  template <class T>
  void allocator<T>::construct(pointer p, const T& val)
  {
    _RWrwstd::_RWconstruct(p,val);
  }

  template <class T>
  void allocator<T>::destroy(T* p)
  {
     _RWrwstd::_RWdestroy(p);
  }

#line 671 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"




  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;
  }






  template <class OutputIterator, class T>
  class raw_storage_iterator

    : public iterator<output_iterator_tag,void,void,void,void>



  {
  protected:
    OutputIterator iter;

  public:
    typedef OutputIterator iterator_type;
    typedef T element_type;

    explicit 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;
    }
  };








#line 744 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"






}

namespace _RWrwstd {


  extern char  stl_temp_buffer[16384];


  extern _RWSTDMutex  stl_temp_buffer_mutex;
  extern bool        stl_temp_buffer_being_used;



} 

namespace std {


  template <class T>

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



  {
    while (len > 16384 / sizeof(T))
    {
      T* tmp = static_cast< T* >(( ::operator new(static_cast< unsigned int >(len) * sizeof(T))));
      if (tmp)
      {
        pair<T*, ptrdiff_t> result(tmp, len);
        return result;
      }
      len = len / 2;
    }
    

    _RWSTDGuard guard(_RWrwstd::stl_temp_buffer_mutex);

    if (_RWrwstd::stl_temp_buffer_being_used)
    {
      T* tmp = static_cast< T* >(( ::operator new(static_cast< unsigned int >(len) * sizeof(T))));
      pair<T*,ptrdiff_t> result(tmp, len);
      return result;
    }
    else
    {
      _RWrwstd::stl_temp_buffer_being_used = true;
      pair<T*, ptrdiff_t> result(static_cast< T* >(static_cast< void* >(_RWrwstd::stl_temp_buffer)), 

                                 static_cast< ptrdiff_t >((16384 / sizeof(T))));
      return result;
    }
#line 809 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"
  }

  template <class T>
  inline void return_temporary_buffer (T* p)
  {

    _RWSTDGuard guard(_RWrwstd::stl_temp_buffer_mutex);

    if (static_cast< char* >(static_cast< void* >(p)) != _RWrwstd::stl_temp_buffer) 

      ::operator delete(p);
    else
      _RWrwstd::stl_temp_buffer_being_used = false;





  }

#line 850 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"






  template <class InputIterator, class ForwardIterator>
  inline ForwardIterator uninitialized_copy (InputIterator first, InputIterator last,
                                                           ForwardIterator result)
  {
    ForwardIterator start = result;

    try {
      while (first != last) 
         _RWrwstd::_RWconstruct(result++, *first++);
    } catch(...) {
       _RWrwstd::_RWdestroy(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) 
         _RWrwstd::_RWconstruct(first++, x);
    } catch(...) {
       _RWrwstd::_RWdestroy(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--) 
         _RWrwstd::_RWconstruct(first++, x);
    } catch(...) {
       _RWrwstd::_RWdestroy(start,first);
      throw;
    }




  }











template <class X> class auto_ptr;


    template <class Y> class auto_ptr_ref 
    {
    public:

      auto_ptr<Y>& p;



      auto_ptr_ref(auto_ptr<Y>& a): p(a) { }
    };




  template<class X> class auto_ptr
  {
#line 958 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/memory"

  public:
    typedef X element_type;

    
    
    
    explicit 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;
    }


     auto_ptr& operator=(auto_ptr_ref<X> r) throw()
    { 
      reset(r.p.release());
      return *this;
    }



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

    template <class Y>
    auto_ptr<X>& operator= (auto_ptr<Y>& rhs)  throw()
    { 
      reset(rhs.release());
      return *this;
    }



    ~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;
      }
    }



    auto_ptr(auto_ptr_ref<X> r) throw(): the_p(r.p.release())



    {




    }

    template <class Y> operator auto_ptr_ref<Y>() throw()
    {
      return auto_ptr_ref<Y>(*this);
    }
    template <class Y> operator auto_ptr<Y>() throw()
    {  
      auto_ptr<Y> tmp;
      tmp.reset(release());
      return tmp;
    }



  private:
    X* the_p;
  };



}








#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 80 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"




#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










#line 102 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"


namespace std {













  template <class T>
  inline const T& min (const T& a, const T& b)
  {
    return b < a ? b : a;
  }


  template <class T, class Compare>
  inline const T& min (const T& a, const T& b, Compare comp)
  {
    return comp(b, a) ? b : a;
  }


  template <class T>
  inline const T& max (const T& a, const T& b)
  {
    return  a < b ? b : a;
  }


  template <class T, class Compare>
  inline const T& max (const T& a, const T& b, Compare comp)
  {
    return comp(a, b) ? b : a;
  }






  template <class OutputIterator, class T>
  class raw_storage_iterator;


  template <class T>

  inline

  void _RWinitialize (T& t, T val) { t = val; }





  template <class InputIterator, class Function>
  Function for_each (InputIterator first, InputIterator last, Function f);

  template <class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& value);

  template <class InputIterator, class Predicate>
  InputIterator find_if (InputIterator first, InputIterator last, Predicate pred);

  template <class ForwardIterator1, class ForwardIterator2, 
  class Distance>
  ForwardIterator1 _RWfind_end (ForwardIterator1 first1,
                               ForwardIterator1 last1,
                               ForwardIterator2 first2,
                               ForwardIterator2 last2,
                               Distance*);

  template <class ForwardIterator1, class ForwardIterator2>
  ForwardIterator1 find_end (ForwardIterator1 first1,
                             ForwardIterator1 last1,
                             ForwardIterator2 first2,
                             ForwardIterator2 last2);

  template <class ForwardIterator1, class ForwardIterator2, 
  class BinaryPredicate, class Distance>
  ForwardIterator1 _RWfind_end (ForwardIterator1 first1,
                               ForwardIterator1 last1,
                               ForwardIterator2 first2,
                               ForwardIterator2 last2,
                               BinaryPredicate pred,
                               Distance*);

  template <class ForwardIterator1, class ForwardIterator2, 
  class BinaryPredicate>
  ForwardIterator1 find_end (ForwardIterator1 first1,
                             ForwardIterator1 last1,
                             ForwardIterator2 first2,
                             ForwardIterator2 last2,
                             BinaryPredicate pred);

  template <class ForwardIterator1, class ForwardIterator2>
  ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1,
                                  ForwardIterator2 first2, ForwardIterator2 last2);

  template <class ForwardIterator1, class ForwardIterator2,
  class BinaryPredicate>
  ForwardIterator1 find_first_of (ForwardIterator1 first1,ForwardIterator1 last1,
                                  ForwardIterator2 first2,ForwardIterator2 last2,
                                  BinaryPredicate pred);

  template <class ForwardIterator>
  ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last);

  template <class ForwardIterator, class BinaryPredicate>
  ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last,
                                 BinaryPredicate binary_pred);


  template <class InputIterator, class T>
  typename iterator_traits<InputIterator>::difference_type
  count (InputIterator first, InputIterator last, const T& value);

  template <class InputIterator, class Predicate>
  typename iterator_traits<InputIterator>::difference_type
  count_if (InputIterator first, InputIterator last, Predicate pred);



  template <class InputIterator, class T, class Size>
  void count (InputIterator first, InputIterator last, const T& value, Size& n);

  template <class InputIterator, class Predicate, class Size>
  void count_if (InputIterator first, InputIterator last, Predicate pred, 
                 Size& n);


  template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
                                                InputIterator1 last1,
                                                InputIterator2 first2);

  template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  pair<InputIterator1, InputIterator2> mismatch (InputIterator1 first1,
                                                 InputIterator1 last1,
                                                 InputIterator2 first2,
                                                 BinaryPredicate binary_pred);

  template <class InputIterator1, class InputIterator2>
  inline bool equal (InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2)
  {
    return mismatch(first1, last1, first2).first == last1;
  }

  template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  inline bool equal (InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, BinaryPredicate binary_pred)
  {
    return mismatch(first1, last1, first2, binary_pred).first == last1;
  }

  template <class ForwardIterator1, class ForwardIterator2,
  class Distance1, class Distance2>
  ForwardIterator1 _RWsearch (ForwardIterator1 first1, ForwardIterator1 last1,
                             ForwardIterator2 first2, ForwardIterator2 last2,
                             Distance1*, Distance2*);

  template <class ForwardIterator1, class ForwardIterator2>
  inline ForwardIterator1 search (ForwardIterator1 first1,ForwardIterator1 last1,
                                  ForwardIterator2 first2,ForwardIterator2 last2)
  {
    return _RWsearch(first1, last1, first2, last2, _RWdistance_type(first1),
                    _RWdistance_type(first2));
  }

  template <class ForwardIterator1, class ForwardIterator2,
  class BinaryPredicate, class Distance1, class Distance2>
  ForwardIterator1 _RWsearch (ForwardIterator1 first1, ForwardIterator1 last1,
                             ForwardIterator2 first2, ForwardIterator2 last2,
                             BinaryPredicate binary_pred, Distance1*, Distance2*);

  template <class ForwardIterator1, class ForwardIterator2,
  class BinaryPredicate>
  inline ForwardIterator1 search (ForwardIterator1 first1,ForwardIterator1 last1,
                                  ForwardIterator2 first2,ForwardIterator2 last2,
                                  BinaryPredicate binary_pred)
  {
    return _RWsearch(first1, last1, first2, last2, binary_pred,
                    _RWdistance_type(first1), _RWdistance_type(first2));
  }

  template <class ForwardIterator, class Distance, class Size, class T>
  ForwardIterator _RWsearch_n (ForwardIterator first, ForwardIterator last,
                              Distance*, Size count, const T& value);
 
  template <class ForwardIterator, class Size, class T>
  inline ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
                                   Size count, const T& value)
  {
    if (count) 
      return _RWsearch_n(first, last, _RWdistance_type(first), count, value);
    else
      return first;
  }

  template <class ForwardIterator, class Distance, class Size, class T,
  class BinaryPredicate>
  ForwardIterator _RWsearch_n (ForwardIterator first, ForwardIterator last,
                              Distance*, Size count, const T& value,
                              BinaryPredicate pred);

  template <class ForwardIterator, class Size, class T, class BinaryPredicate>
  inline ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
                                   Size count, const T& value,
                                   BinaryPredicate pred)
  {
    if (count) 
      return  _RWsearch_n(first, last, _RWdistance_type(first), count,value, pred);
    else
      return first;
  }





  template <class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last,
                       OutputIterator result);

  template <class BidirectionalIterator1, class BidirectionalIterator2>
  BidirectionalIterator2 copy_backward (BidirectionalIterator1 first, 
                                        BidirectionalIterator1 last, 
                                        BidirectionalIterator2 result);

  template <class T>
  inline void swap (T& a, T& b)
  {
    T tmp = a;
    a = b;
    b = tmp;
  }

  template <class ForwardIterator1, class ForwardIterator2, class T>
  inline void _RWiter_swap (ForwardIterator1 a, ForwardIterator2 b, T*)
  {
    T tmp = *a;
    *a = *b;
    *b = tmp;
  }

  template <class ForwardIterator1, class ForwardIterator2>
  inline void iter_swap (ForwardIterator1 a, ForwardIterator2 b)
  {
    _RWiter_swap(a, b, _RWvalue_type(a));
  }

  template <class ForwardIterator1, class ForwardIterator2>
  ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2);

  template <class InputIterator, class OutputIterator, class UnaryOperation>
  OutputIterator transform (InputIterator first, InputIterator last,
                            OutputIterator result, UnaryOperation op);

  template <class InputIterator1, class InputIterator2, class OutputIterator,
  class BinaryOperation>
  OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,
                            BinaryOperation binary_op);

  template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last, const T& old_value,
                const T& new_value);

  template <class ForwardIterator, class Predicate, class T>
  void replace_if (ForwardIterator first, ForwardIterator last, Predicate pred,
                   const T& new_value);

  template <class InputIterator, class OutputIterator, class T>
  OutputIterator replace_copy (InputIterator first, InputIterator last,
                               OutputIterator result, const T& old_value,
                               const T& new_value);

  template <class Iterator, class OutputIterator, class Predicate, class T>
  OutputIterator replace_copy_if (Iterator first, Iterator last,
                                  OutputIterator result, Predicate pred,
                                  const T& new_value);

  template <class ForwardIterator, class T>



  void fill (ForwardIterator first, ForwardIterator last, const T& value);


  template <class OutputIterator, class Size, class T>
  void fill_n (OutputIterator first, Size n, const T& value);

  template <class ForwardIterator, class Generator>
  void generate (ForwardIterator first, ForwardIterator last, Generator gen);

  template <class OutputIterator, class Size, class Generator>
  void generate_n (OutputIterator first, Size n, Generator gen);

  template <class InputIterator, class OutputIterator, class T>
  OutputIterator remove_copy (InputIterator first, InputIterator last,
                              OutputIterator result, const T& value);

  template <class InputIterator, class OutputIterator, class Predicate>
  OutputIterator remove_copy_if (InputIterator first, InputIterator last,
                                 OutputIterator result, Predicate pred);

  template <class ForwardIterator, class T>
  inline ForwardIterator remove (ForwardIterator first, ForwardIterator last,
                                 const T& value)
  {
    first = find(first, last, value);
    ForwardIterator next = first;
    return first == last ? first : remove_copy(++next, last, first, value);
  }

  template <class ForwardIterator, class Predicate>
  inline ForwardIterator remove_if (ForwardIterator first, ForwardIterator last,
                                    Predicate pred)
  {
    first = find_if(first, last, pred);
    ForwardIterator next = first;
    return first == last ? first : remove_copy_if(++next, last, first, pred);
  }

  template <class InputIterator, class ForwardIterator>
  ForwardIterator _RWunique_copy (InputIterator first, InputIterator last,
                                 ForwardIterator result, forward_iterator_tag);

  template <class InputIterator, class BidirectionalIterator>
  inline BidirectionalIterator _RWunique_copy (InputIterator first, 
                                              InputIterator last,
                                              BidirectionalIterator result, 
                                              bidirectional_iterator_tag)
  {
    return _RWunique_copy(first, last, result, forward_iterator_tag());
  }

  template <class InputIterator, class RandomAccessIterator>
  inline RandomAccessIterator _RWunique_copy (InputIterator first, 
                                             InputIterator last,
                                             RandomAccessIterator result, 
                                             random_access_iterator_tag)
  {
    return _RWunique_copy(first, last, result, forward_iterator_tag());
  }

  template <class InputIterator, class OutputIterator, class T>
  OutputIterator _RWunique_copy (InputIterator first, InputIterator last,
                                OutputIterator result, T*);

  template <class InputIterator, class OutputIterator>
  inline OutputIterator _RWunique_copy (InputIterator first, InputIterator last,
                                       OutputIterator result, 
                                       output_iterator_tag)
  {
    return _RWunique_copy(first, last, result, _RWvalue_type(first));
  }

  template <class InputIterator, class OutputIterator>
  inline OutputIterator unique_copy (InputIterator first, InputIterator last,
                                     OutputIterator result)
  {
    return first == last ? result :

    _RWunique_copy(first, last, result, _RWiterator_category(result));



  }

  template <class InputIterator, class ForwardIterator, class BinaryPredicate>
  ForwardIterator _RWunique_copy (InputIterator first, InputIterator last,
                                 ForwardIterator result, 
                                 BinaryPredicate binary_pred,
                                 forward_iterator_tag);
  template <class InputIterator, class BidirectionalIterator,
  class BinaryPredicate>
  inline BidirectionalIterator _RWunique_copy (InputIterator first, 
                                              InputIterator last,
                                              BidirectionalIterator result, 
                                              BinaryPredicate binary_pred,
                                              bidirectional_iterator_tag)
  {
    return _RWunique_copy(first, last, result, binary_pred,
                         forward_iterator_tag());
  }

  template <class InputIterator, class RandomAccessIterator,
  class BinaryPredicate>
  inline RandomAccessIterator _RWunique_copy (InputIterator first, 
                                             InputIterator last,
                                             RandomAccessIterator result, 
                                             BinaryPredicate binary_pred,
                                             random_access_iterator_tag)
  {
    return _RWunique_copy(first, last, result, binary_pred, 
                         forward_iterator_tag());
  }

  template <class InputIterator, class OutputIterator, class BinaryPredicate,
  class T>
  OutputIterator _RWunique_copy (InputIterator first, InputIterator last,
                                OutputIterator result,
                                BinaryPredicate binary_pred, T*);

  template <class InputIterator, class OutputIterator, class BinaryPredicate>
  inline OutputIterator _RWunique_copy (InputIterator first, InputIterator last,
                                       OutputIterator result,
                                       BinaryPredicate binary_pred,
                                       output_iterator_tag)
  {
    return _RWunique_copy(first, last, result, binary_pred,
                         _RWvalue_type(first));
  }

  template <class InputIterator, class OutputIterator, class BinaryPredicate>
  inline OutputIterator unique_copy (InputIterator first, InputIterator last,
                                     OutputIterator result,
                                     BinaryPredicate binary_pred)
  {
    return first == last ? result :

    _RWunique_copy(first, last, result, binary_pred, _RWiterator_category(result));



  }

  template <class ForwardIterator>
  inline ForwardIterator unique (ForwardIterator first, ForwardIterator last)
  {
    first = adjacent_find(first, last);
    return unique_copy(first, last, first);
  }

  template <class ForwardIterator, class BinaryPredicate>
  inline ForwardIterator unique (ForwardIterator first, ForwardIterator last,
                                 BinaryPredicate binary_pred)
  {
    first = adjacent_find(first, last, binary_pred);
    return unique_copy(first, last, first, binary_pred);
  }

  template <class BidirectionalIterator>
  void _RWreverse (BidirectionalIterator first, BidirectionalIterator last, 
                  bidirectional_iterator_tag);

  template <class RandomAccessIterator>
  void _RWreverse (RandomAccessIterator first, RandomAccessIterator last,
                  random_access_iterator_tag);

  template <class BidirectionalIterator>
  inline void reverse (BidirectionalIterator first, BidirectionalIterator last)
  {

    _RWreverse(first, last, _RWiterator_category(first));



  }

  template <class BidirectionalIterator, class OutputIterator>
  OutputIterator reverse_copy (BidirectionalIterator first,
                               BidirectionalIterator last,
                               OutputIterator result);

  template <class ForwardIterator, class Distance>
  void _RWrotate (ForwardIterator first, ForwardIterator middle,
                 ForwardIterator last, Distance*, forward_iterator_tag);

  template <class BidirectionalIterator, class Distance>
  inline void _RWrotate (BidirectionalIterator first, 
                        BidirectionalIterator middle,
                        BidirectionalIterator last, Distance*,
                        bidirectional_iterator_tag)
  {
    reverse(first, middle);
    reverse(middle, last);
    reverse(first, last);
  }

  template <class EuclideanRingElement>
  EuclideanRingElement _RWgcd (EuclideanRingElement m, EuclideanRingElement n);

  template <class RandomAccessIterator, class Distance, class T>
  void _RWrotate_cycle (RandomAccessIterator first, RandomAccessIterator last,
                       RandomAccessIterator initial, Distance shift, T*);

  template <class RandomAccessIterator, class Distance>
  void _RWrotate (RandomAccessIterator first, RandomAccessIterator middle,
                 RandomAccessIterator last, Distance*,
                 random_access_iterator_tag);

  template <class ForwardIterator>
  inline void rotate (ForwardIterator first, ForwardIterator middle,
                      ForwardIterator last)
  {
    if (!(first == middle || middle == last))
    {


      _RWrotate(first, middle, last, _RWdistance_type(first), _RWiterator_category(first));



    }
  }

  template <class ForwardIterator, class OutputIterator>
  inline OutputIterator rotate_copy (ForwardIterator first,
                                     ForwardIterator middle,
                                     ForwardIterator last,
                                     OutputIterator result)
  {
    return copy(first, middle, copy(middle, last, result));
  }



  template <class RandomAccessIterator, class Distance>
  void _RWrandom_shuffle (RandomAccessIterator first, RandomAccessIterator last,
                         Distance*);

  template <class RandomAccessIterator>
  inline void random_shuffle (RandomAccessIterator first,
                              RandomAccessIterator last)
  {
    _RWrandom_shuffle(first, last, _RWdistance_type(first));
  }

  template <class RandomAccessIterator, class RandomNumberGenerator>
  void random_shuffle (RandomAccessIterator first, RandomAccessIterator last,
                       RandomNumberGenerator& rand);

  template <class BidirectionalIterator, class Predicate>
  BidirectionalIterator partition (BidirectionalIterator first,
                                   BidirectionalIterator last, Predicate pred);

  template <class BidirectionalIterator, class Predicate, class Distance>
  BidirectionalIterator _RWinplace_stable_partition (BidirectionalIterator first,
                                                    BidirectionalIterator last,
                                                    Predicate pred,
                                                    Distance len);

  template <class BidirectionalIterator, class Pointer, class Predicate,
  class Distance, class T>
  BidirectionalIterator _RWstable_partition_adaptive (BidirectionalIterator first,
                                                     BidirectionalIterator last,
                                                     Predicate pred, Distance len,
                                                     Pointer buffer,
                                                     Distance buffer_size,
                                                     Distance& fill_pointer, T*);

  template <class BidirectionalIterator, class Predicate, class Pointer,
  class Distance>
  BidirectionalIterator _RWstable_partition (BidirectionalIterator first,
                                            BidirectionalIterator last,
                                            Predicate pred, Distance len,

                                            pair<Pointer, ptrdiff_t> p);




  template <class BidirectionalIterator, class Predicate, class Distance>
  inline BidirectionalIterator _RWstable_partition_aux (BidirectionalIterator first,
                                                       BidirectionalIterator last, 
                                                       Predicate pred,
                                                       Distance*)
  {
    Distance len;
    _RWinitialize(len, Distance(0));

   len = distance(first, last);




    return len == 0 ? last :
    _RWstable_partition(first, last, pred, len,

           get_temporary_buffer<typename 
               iterator_traits<BidirectionalIterator>::value_type >(len));



  }

  template <class BidirectionalIterator, class Predicate>
  inline BidirectionalIterator stable_partition (BidirectionalIterator first,
                                                 BidirectionalIterator last, 
                                                 Predicate pred)
  {
    return _RWstable_partition_aux(first, last, pred, _RWdistance_type(first));
  }





  template <class T>
  inline const T& _RWmedian (const T& a, const T& b, const T& c)
  {
    if (a < b)
      if (b < c)
        return b;
      else if (a < c)
        return c;
      else
        return a;
    else if (a < c)
      return a;
    else if (b < c)
      return c;
    else
      return b;
  }

  template <class T, class Compare>
  inline const T& _RWmedian (const T& a, const T& b, const T& c, Compare comp)
  {
    if (comp(a, b))
      if (comp(b, c))
        return b;
      else if (comp(a, c))
        return c;
      else
        return a;
    else if (comp(a, c))
      return a;
    else if (comp(b, c))
      return c;
    else
      return b;
  }

  template <class RandomAccessIterator, class T>
  RandomAccessIterator _RWunguarded_partition (RandomAccessIterator first, 
                                              RandomAccessIterator last, 
                                              T pivot);

  template <class RandomAccessIterator, class T, class Compare>
  RandomAccessIterator _RWunguarded_partition (RandomAccessIterator first, 
                                              RandomAccessIterator last, 
                                              T pivot, Compare comp);

  template <class RandomAccessIterator, class T>
  void _RWquick_sort_loop_aux (RandomAccessIterator first,
                              RandomAccessIterator last, T*);

  template <class RandomAccessIterator>
  inline void _RWquick_sort_loop (RandomAccessIterator first,
                                 RandomAccessIterator last)
  {
    _RWquick_sort_loop_aux(first, last, _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class T, class Compare>
  void _RWquick_sort_loop_aux (RandomAccessIterator first, 
                              RandomAccessIterator last, T*, Compare comp);

  template <class RandomAccessIterator, class Compare>
  inline void _RWquick_sort_loop (RandomAccessIterator first, 
                                 RandomAccessIterator last, Compare comp)
  {
    _RWquick_sort_loop_aux(first, last, _RWvalue_type(first), comp);
  }

  template <class RandomAccessIterator, class T>
  void _RWunguarded_linear_insert (RandomAccessIterator last, T value);

  template <class RandomAccessIterator, class T, class Compare>
  void _RWunguarded_linear_insert (RandomAccessIterator last,T value,Compare comp);

  template <class RandomAccessIterator, class T>
  inline void _RWlinear_insert (RandomAccessIterator first, 
                               RandomAccessIterator last, T*)
  {
    T value = *last;
    if (value < *first)
    {
      copy_backward(first, last, last + 1);
      *first = value;
    }
    else
      _RWunguarded_linear_insert(last, value);
  }

  template <class RandomAccessIterator, class T, class Compare>
  inline void _RWlinear_insert (RandomAccessIterator first, 
                               RandomAccessIterator last, T*, Compare comp)
  {
    T value = *last;
    if (comp(value, *first))
    {
      copy_backward(first, last, last + 1);
      *first = value;
    }
    else
      _RWunguarded_linear_insert(last, value, comp);
  }

  template <class RandomAccessIterator>
  void _RWinsertion_sort (RandomAccessIterator first, RandomAccessIterator last);

  template <class RandomAccessIterator, class Compare>
  void _RWinsertion_sort (RandomAccessIterator first,
                         RandomAccessIterator last, Compare comp);

  template <class RandomAccessIterator, class T>
  void _RWunguarded_insertion_sort_aux (RandomAccessIterator first, 
                                       RandomAccessIterator last, T*);

  template <class RandomAccessIterator>
  inline void _RWunguarded_insertion_sort(RandomAccessIterator first, 
                                         RandomAccessIterator last)
  {
    _RWunguarded_insertion_sort_aux(first, last, _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class T, class Compare>
  void _RWunguarded_insertion_sort_aux (RandomAccessIterator first, 
                                       RandomAccessIterator last,
                                       T*, Compare comp);

  template <class RandomAccessIterator, class Compare>
  inline void _RWunguarded_insertion_sort (RandomAccessIterator first, 
                                          RandomAccessIterator last,
                                          Compare comp)
  {
    _RWunguarded_insertion_sort_aux(first, last, _RWvalue_type(first), comp);
  }

  template <class RandomAccessIterator>
  void _RWfinal_insertion_sort (RandomAccessIterator first, 
                               RandomAccessIterator last);

  template <class RandomAccessIterator, class Compare>
  void _RWfinal_insertion_sort (RandomAccessIterator first, 
                               RandomAccessIterator last, Compare comp);

  template <class RandomAccessIterator>
  inline void sort (RandomAccessIterator first, RandomAccessIterator last)
  {
    if (!(first == last))
    {
      _RWquick_sort_loop(first, last);
      _RWfinal_insertion_sort(first, last);
    }
  }

  template <class RandomAccessIterator, class Compare>
  inline void sort (RandomAccessIterator first, 
                    RandomAccessIterator last, Compare comp)
  {
    if (!(first == last))
    {
      _RWquick_sort_loop(first, last, comp);
      _RWfinal_insertion_sort(first, last, comp);
    }
  }







  template <class BidirectionalIterator, class Distance>
  void _RWmerge_without_buffer (BidirectionalIterator first,
                               BidirectionalIterator middle,
                               BidirectionalIterator last,
                               Distance len1, Distance len2);

  template <class BidirectionalIterator, class Distance, class Compare>
  void _RWmerge_without_buffer (BidirectionalIterator first,
                               BidirectionalIterator middle,
                               BidirectionalIterator last,
                               Distance len1, Distance len2, Compare comp);



  template <class RandomAccessIterator>
  inline void _RWinplace_stable_sort (RandomAccessIterator first,
                                     RandomAccessIterator last)
  {
    if (last - first < 15)
      _RWinsertion_sort(first, last);
    else
    {
      RandomAccessIterator middle = first + (last - first) / 2;
      _RWinplace_stable_sort(first, middle);
      _RWinplace_stable_sort(middle, last);
      _RWmerge_without_buffer(first, middle, last, middle - first,
                             last - middle);
    }
  }

  template <class RandomAccessIterator, class Compare>
  inline void _RWinplace_stable_sort (RandomAccessIterator first,
                                     RandomAccessIterator last, Compare comp)
  {
    if (last - first < 15)
      _RWinsertion_sort(first, last, comp);
    else
    {
      RandomAccessIterator middle = first + (last - first) / 2;
      _RWinplace_stable_sort(first, middle, comp);
      _RWinplace_stable_sort(middle, last, comp);
      _RWmerge_without_buffer(first, middle, last, middle - first,
                             last - middle, comp);
    }
  }

  template <class RandomAccessIterator1, class RandomAccessIterator2,
  class Distance>
  void _RWmerge_sort_loop (RandomAccessIterator1 first,
                          RandomAccessIterator1 last, 
                          RandomAccessIterator2 result, Distance step_size);

  template <class RandomAccessIterator1, class RandomAccessIterator2,
  class Distance, class Compare>
  void _RWmerge_sort_loop (RandomAccessIterator1 first,
                          RandomAccessIterator1 last, 
                          RandomAccessIterator2 result, Distance step_size,
                          Compare comp);

  template <class RandomAccessIterator, class Distance>
  void _RWchunk_insertion_sort (RandomAccessIterator first, 
                               RandomAccessIterator last, Distance chunk_size);

  template <class RandomAccessIterator, class Distance, class Compare>
  void _RWchunk_insertion_sort (RandomAccessIterator first, 
                               RandomAccessIterator last,
                               Distance chunk_size, Compare comp);

  template <class RandomAccessIterator, class Pointer, class Distance, class T>
  void _RWmerge_sort_with_buffer (RandomAccessIterator first, 
                                 RandomAccessIterator last,
                                 Pointer buffer, Distance*, T*);

  template <class RandomAccessIterator, class Pointer, class Distance, class T,
  class Compare>
  void _RWmerge_sort_with_buffer (RandomAccessIterator first, 
                                 RandomAccessIterator last, Pointer buffer,
                                 Distance*, T*, Compare comp);

  template <class RandomAccessIterator, class Pointer, class Distance, class T>
  void _RWstable_sort_adaptive (RandomAccessIterator first, 
                               RandomAccessIterator last, Pointer buffer,
                               Distance buffer_size, T*);

  template <class RandomAccessIterator, class Pointer, class Distance, class T,
  class Compare>
  void _RWstable_sort_adaptive (RandomAccessIterator first, 
                               RandomAccessIterator last, Pointer buffer,
                               Distance buffer_size, T*, Compare comp);

  template <class RandomAccessIterator, class Pointer, class Distance, class T>
  inline void _RWstable_sort (RandomAccessIterator first,
                             RandomAccessIterator last,
                             pair<Pointer, Distance>& p, T*)
  {
    if (p.first == 0)
      _RWinplace_stable_sort(first, last);
    else
    {
      Distance len = min((int)p.second, (int)(last - first));
      copy(first, first + len, raw_storage_iterator<Pointer, T>(p.first));
      _RWstable_sort_adaptive(first, last, p.first, p.second, static_cast< T* >(0));
      _RWrwstd::_RWdestroy(p.first, p.first + len);
      return_temporary_buffer(p.first);
    }
  }

  template <class RandomAccessIterator, class Pointer, class Distance, class T,
  class Compare>
  inline void _RWstable_sort (RandomAccessIterator first,
                             RandomAccessIterator last,
                             pair<Pointer, Distance>& p, T*, Compare comp)
  {
    if (p.first == 0)
      _RWinplace_stable_sort(first, last, comp);
    else
    {
      Distance len = min((int)p.second, (int)(last - first));
      copy(first, first + len, raw_storage_iterator<Pointer, T>(p.first));
      _RWstable_sort_adaptive(first, last, p.first, p.second, static_cast< T* >(0), comp);
      _RWrwstd::_RWdestroy(p.first, p.first + len);
      return_temporary_buffer(p.first);
    }
  }

  template <class RandomAccessIterator, class T, class Distance>
  inline void _RWstable_sort_aux (RandomAccessIterator first,
                                 RandomAccessIterator last, T*, Distance*)
  {

    pair<T*, Distance> tmp = 

         get_temporary_buffer<T>(Distance(last-first));



    _RWstable_sort(first, last, tmp, static_cast< T* >(0));
  }

  template <class RandomAccessIterator, class T, class Distance, class Compare>
  inline void _RWstable_sort_aux (RandomAccessIterator first,
                                 RandomAccessIterator last, T*, Distance*,
                                 Compare comp)
  {
    pair<T*, Distance> tmp = 

        get_temporary_buffer<T>(Distance(last-first));



    _RWstable_sort(first, last, tmp, static_cast< T* >(0), comp);
  }

  template <class RandomAccessIterator>
  inline void stable_sort (RandomAccessIterator first,
                           RandomAccessIterator last)
  {
    if (!(first == last))
    {
      _RWstable_sort_aux(first, last, _RWvalue_type(first),
                        _RWdistance_type(first));
    }
  }

  template <class RandomAccessIterator, class Compare>
  inline void stable_sort (RandomAccessIterator first,
                           RandomAccessIterator last, Compare comp)
  {
    if (!(first == last))
    {
      _RWstable_sort_aux(first, last, _RWvalue_type(first),
                        _RWdistance_type(first), comp);
    }
  }

  template <class RandomAccessIterator, class T>
  void _RWpartial_sort (RandomAccessIterator first, RandomAccessIterator middle,
                       RandomAccessIterator last, T*);

  template <class RandomAccessIterator>
  inline void partial_sort (RandomAccessIterator first,
                            RandomAccessIterator middle,
                            RandomAccessIterator last)
  {
    if (!(first == middle))
      _RWpartial_sort(first, middle, last, _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class T, class Compare>
  void _RWpartial_sort (RandomAccessIterator first, RandomAccessIterator middle,
                       RandomAccessIterator last, T*, Compare comp);

  template <class RandomAccessIterator, class Compare>
  inline void partial_sort (RandomAccessIterator first,
                            RandomAccessIterator middle,
                            RandomAccessIterator last, Compare comp)
  {
    if (!(first == middle))
      _RWpartial_sort(first, middle, last, _RWvalue_type(first), comp);
  }

  template <class InputIterator, class RandomAccessIterator, class Distance,
  class T>
  RandomAccessIterator _RWpartial_sort_copy (InputIterator first,
                                            InputIterator last,
                                            RandomAccessIterator result_first,
                                            RandomAccessIterator result_last, 
                                            Distance*, T*);

  template <class InputIterator, class RandomAccessIterator>
  inline RandomAccessIterator
  partial_sort_copy (InputIterator first, InputIterator last,
                     RandomAccessIterator result_first,
                     RandomAccessIterator result_last)
  {
    return first == last ? result_first :
    _RWpartial_sort_copy(first, last, result_first, result_last, 
                        _RWdistance_type(result_first),
                        _RWvalue_type(first));
  }

  template <class InputIterator, class RandomAccessIterator, class Compare,
  class Distance, class T>
  RandomAccessIterator _RWpartial_sort_copy (InputIterator first,
                                            InputIterator last,
                                            RandomAccessIterator result_first,
                                            RandomAccessIterator result_last,
                                            Compare comp, Distance*, T*);

  template <class InputIterator, class RandomAccessIterator, class Compare>
  inline RandomAccessIterator
  partial_sort_copy (InputIterator first, InputIterator last,
                     RandomAccessIterator result_first,
                     RandomAccessIterator result_last, Compare comp)
  {
    return first == last ? result_first :
    _RWpartial_sort_copy(first, last, result_first, result_last, comp,
                        _RWdistance_type(result_first),
                        _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class T>
  void _RWnth_element (RandomAccessIterator first, RandomAccessIterator nth,
                      RandomAccessIterator last, T*);

  template <class RandomAccessIterator>
  inline void nth_element (RandomAccessIterator first, RandomAccessIterator nth,
                           RandomAccessIterator last)
  {
    if (!(first == last))
      _RWnth_element(first, nth, last, _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class T, class Compare>
  void _RWnth_element (RandomAccessIterator first, RandomAccessIterator nth,
                      RandomAccessIterator last, T*, Compare comp);

  template <class RandomAccessIterator, class Compare>
  inline void nth_element (RandomAccessIterator first, RandomAccessIterator nth,
                           RandomAccessIterator last, Compare comp)
  {
    if (!(first == last))
      _RWnth_element(first, nth, last, _RWvalue_type(first), comp);
  }





  template <class ForwardIterator, class T, class Distance>
  ForwardIterator _RWlower_bound (ForwardIterator first, ForwardIterator last,
                                 const T& value, Distance*,
                                 forward_iterator_tag);

  template <class ForwardIterator, class T, class Distance>
  inline ForwardIterator _RWlower_bound (ForwardIterator first,
                                        ForwardIterator last,
                                        const T& value, Distance*,
                                        bidirectional_iterator_tag)
  {
    return _RWlower_bound(first, last, value, static_cast< Distance* >(0),
                         forward_iterator_tag());
  }

  template <class RandomAccessIterator, class T, class Distance>
  RandomAccessIterator _RWlower_bound (RandomAccessIterator first,
                                      RandomAccessIterator last, const T& value,
                                      Distance*, random_access_iterator_tag);

  template <class ForwardIterator, class T>
  inline ForwardIterator lower_bound (ForwardIterator first,ForwardIterator last,
                                      const T& value)
  {


    return _RWlower_bound(first, last, value, _RWdistance_type(first),                         _RWiterator_category(first));




  }

  template <class ForwardIterator, class T, class Compare, class Distance>
  ForwardIterator _RWlower_bound (ForwardIterator first, ForwardIterator last,
                                 const T& value, Compare comp, Distance*,
                                 forward_iterator_tag);

  template <class ForwardIterator, class T, class Compare, class Distance>
  inline ForwardIterator _RWlower_bound (ForwardIterator first,
                                        ForwardIterator last,
                                        const T& value, Compare comp, Distance*,
                                        bidirectional_iterator_tag)
  {
    return _RWlower_bound(first, last, value, comp,static_cast< Distance* >(0),
                         forward_iterator_tag());
  }

  template <class RandomAccessIterator, class T, class Compare, class Distance>
  RandomAccessIterator _RWlower_bound (RandomAccessIterator first,
                                      RandomAccessIterator last,
                                      const T& value, Compare comp, Distance*,
                                      random_access_iterator_tag);

  template <class ForwardIterator, class T, class Compare>
  inline ForwardIterator lower_bound (ForwardIterator first,ForwardIterator last,
                                      const T& value, Compare comp)
  {

    return _RWlower_bound(first, last, value, comp, _RWdistance_type(first),
                         _RWiterator_category(first));




  }

  template <class ForwardIterator, class T, class Distance>
  ForwardIterator _RWupper_bound (ForwardIterator first, ForwardIterator last,
                                 const T& value, Distance*,
                                 forward_iterator_tag);

  template <class ForwardIterator, class T, class Distance>
  inline ForwardIterator _RWupper_bound (ForwardIterator first,
                                        ForwardIterator last,
                                        const T& value, Distance*,
                                        bidirectional_iterator_tag)
  {
    return _RWupper_bound(first, last, value, static_cast< Distance* >(0),
                         forward_iterator_tag());
  }

  template <class RandomAccessIterator, class T, class Distance>
  RandomAccessIterator _RWupper_bound (RandomAccessIterator first,
                                      RandomAccessIterator last, const T& value,
                                      Distance*, random_access_iterator_tag);

  template <class ForwardIterator, class T>
  inline ForwardIterator upper_bound (ForwardIterator first,ForwardIterator last,
                                      const T& value)
  {

    return _RWupper_bound(first, last, value, _RWdistance_type(first),
                         _RWiterator_category(first));




  }

  template <class ForwardIterator, class T, class Compare, class Distance>
  ForwardIterator _RWupper_bound (ForwardIterator first, ForwardIterator last,
                                 const T& value, Compare comp, Distance*,
                                 forward_iterator_tag);

  template <class ForwardIterator, class T, class Compare, class Distance>
  inline ForwardIterator _RWupper_bound (ForwardIterator first,
                                        ForwardIterator last,
                                        const T& value, Compare comp, Distance*,
                                        bidirectional_iterator_tag)
  {
    return _RWupper_bound(first, last, value, comp, static_cast< Distance* >(0),
                         forward_iterator_tag());
  }

  template <class RandomAccessIterator, class T, class Compare, class Distance>
  RandomAccessIterator _RWupper_bound (RandomAccessIterator first,
                                      RandomAccessIterator last,
                                      const T& value, Compare comp, Distance*,
                                      random_access_iterator_tag);

  template <class ForwardIterator, class T, class Compare>
  inline ForwardIterator upper_bound (ForwardIterator first,ForwardIterator last,
                                      const T& value, Compare comp)
  {

    return _RWupper_bound(first, last, value, comp, _RWdistance_type(first),
                         _RWiterator_category(first));




  }

  template <class ForwardIterator, class T, class Distance>
  pair<ForwardIterator, ForwardIterator>
  _RWequal_range (ForwardIterator first, ForwardIterator last, const T& value,
                 Distance*, forward_iterator_tag);

  template <class ForwardIterator, class T, class Distance>
  inline pair<ForwardIterator, ForwardIterator>
  _RWequal_range (ForwardIterator first, ForwardIterator last, const T& value,
                 Distance*, bidirectional_iterator_tag)
  {
    return _RWequal_range(first, last, value, static_cast< Distance* >(0), 
                         forward_iterator_tag());
  }

  template <class RandomAccessIterator, class T, class Distance>
  pair<RandomAccessIterator, RandomAccessIterator>
  _RWequal_range (RandomAccessIterator first, RandomAccessIterator last,
                 const T& value, Distance*, random_access_iterator_tag);

  template <class ForwardIterator, class T>
  inline pair<ForwardIterator, ForwardIterator>
  equal_range (ForwardIterator first, ForwardIterator last, const T& value)
  {

    return _RWequal_range(first, last, value, _RWdistance_type(first),
                         _RWiterator_category(first));




  }

  template <class ForwardIterator, class T, class Compare, class Distance>
  pair<ForwardIterator, ForwardIterator>
  _RWequal_range (ForwardIterator first, ForwardIterator last, const T& value,
                 Compare comp, Distance*, forward_iterator_tag);

  template <class ForwardIterator, class T, class Compare, class Distance>
  inline pair<ForwardIterator, ForwardIterator>
  _RWequal_range (ForwardIterator first, ForwardIterator last, const T& value,
                 Compare comp, Distance*, bidirectional_iterator_tag)
  {
    return _RWequal_range(first, last, value, comp, static_cast< Distance* >(0), 
                         forward_iterator_tag());
  }

  template <class RandomAccessIterator, class T, class Compare, class Distance>
  pair<RandomAccessIterator, RandomAccessIterator>
  _RWequal_range (RandomAccessIterator first, RandomAccessIterator last,
                 const T& value, Compare comp, Distance*,
                 random_access_iterator_tag);

  template <class ForwardIterator, class T, class Compare>
  inline pair<ForwardIterator, ForwardIterator>
  equal_range (ForwardIterator first, ForwardIterator last, const T& value,
               Compare comp)
  {

    return _RWequal_range(first, last, value, comp, _RWdistance_type(first),
                         _RWiterator_category(first));




  }    

  template <class ForwardIterator, class T>
  inline bool binary_search (ForwardIterator first, ForwardIterator last,
                             const T& value)
  {
    ForwardIterator i = lower_bound(first, last, value);
    return i != last && !(value < *i);
  }

  template <class ForwardIterator, class T, class Compare>
  inline bool binary_search (ForwardIterator first, ForwardIterator last,
                             const T& value, Compare comp)
  {
    ForwardIterator i = lower_bound(first, last, value, comp);
    return i != last && !comp(value, *i);
  }





  template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result);

  template <class InputIterator1, class InputIterator2, class OutputIterator,
  class Compare>
  OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result, Compare comp);

#line 1394 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"

  template <class BidirectionalIterator1, class BidirectionalIterator2,
  class Distance>
  BidirectionalIterator1 _RWrotate_adaptive (BidirectionalIterator1 first,
                                            BidirectionalIterator1 middle,
                                            BidirectionalIterator1 last,
                                            Distance len1, Distance len2,
                                            BidirectionalIterator2 buffer,
                                            Distance buffer_size);

  template <class BidirectionalIterator1, class BidirectionalIterator2,
  class BidirectionalIterator3>
  BidirectionalIterator3 _RWmerge_backward (BidirectionalIterator1 first1,
                                           BidirectionalIterator1 last1,
                                           BidirectionalIterator2 first2,
                                           BidirectionalIterator2 last2,
                                           BidirectionalIterator3 result);

  template <class BidirectionalIterator1, class BidirectionalIterator2,
  class BidirectionalIterator3, class Compare>
  BidirectionalIterator3 _RWmerge_backward (BidirectionalIterator1 first1,
                                           BidirectionalIterator1 last1,
                                           BidirectionalIterator2 first2,
                                           BidirectionalIterator2 last2,
                                           BidirectionalIterator3 result,
                                           Compare comp);

  template <class BidirectionalIterator, class Distance, class Pointer, class T>
  void _RWmerge_adaptive (BidirectionalIterator first,
                         BidirectionalIterator middle,
                         BidirectionalIterator last, Distance len1,Distance len2,
                         Pointer buffer, Distance buffer_size, T*);

  template <class BidirectionalIterator, class Distance, class Pointer, class T,
  class Compare>
  void _RWmerge_adaptive (BidirectionalIterator first,
                         BidirectionalIterator middle,
                         BidirectionalIterator last, Distance len1,Distance len2,
                         Pointer buffer, Distance buffer_size, T*, Compare comp);

  template <class BidirectionalIterator, class Distance, class Pointer, class T>
  void _RWinplace_merge (BidirectionalIterator first,
                        BidirectionalIterator middle, 
                        BidirectionalIterator last, Distance len1,

                        Distance len2, pair<Pointer, ptrdiff_t> p, T*);




  template <class BidirectionalIterator, class Distance, class Pointer, class T,
  class Compare>
  void _RWinplace_merge (BidirectionalIterator first,
                        BidirectionalIterator middle,
                        BidirectionalIterator last, Distance len1,

                        Distance len2, pair<Pointer, ptrdiff_t> p, T*,



                        Compare comp);

  template <class BidirectionalIterator, class T, class Distance>
  inline void _RWinplace_merge_aux (BidirectionalIterator first,
                                   BidirectionalIterator middle,
                                   BidirectionalIterator last, T*, Distance*)
  {
    Distance len1;
    _RWinitialize(len1, Distance(0));


   len1 = distance(first, middle);




    Distance len2;
    _RWinitialize(len2, Distance(0));


   len2 = distance(middle, last);




    _RWinplace_merge(first, middle, last, len1, len2, 

        get_temporary_buffer<T>(len1+len2),static_cast< T* >(0));




  }

  template <class BidirectionalIterator, class T, class Distance, class Compare>
  inline void _RWinplace_merge_aux (BidirectionalIterator first,
                                   BidirectionalIterator middle,
                                   BidirectionalIterator last, T*, Distance*,
                                   Compare comp)
  {
    Distance len1;
    _RWinitialize(len1, Distance(0));


   len1 = distance(first, middle);




    Distance len2;
    _RWinitialize(len2, Distance(0));


   len2 = distance(middle, last);





    _RWinplace_merge(first, middle, last, len1, len2, 

        get_temporary_buffer<T>(len1+len2), static_cast< T* >(0), comp);



  }

  template <class BidirectionalIterator>
  inline void inplace_merge (BidirectionalIterator first,
                             BidirectionalIterator middle,
                             BidirectionalIterator last)
  {
    if (!(first == middle || middle == last))
      _RWinplace_merge_aux(first, middle, last, _RWvalue_type(first),
                          _RWdistance_type(first));
  }

  template <class BidirectionalIterator, class Compare>
  inline void inplace_merge (BidirectionalIterator first,
                             BidirectionalIterator middle,
                             BidirectionalIterator last, Compare comp)
  {
    if (!(first == middle || middle == last))
      _RWinplace_merge_aux(first, middle, last, _RWvalue_type(first),
                          _RWdistance_type(first), comp);
  }





  template <class InputIterator1, class InputIterator2>
  bool includes (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2);

  template <class InputIterator1, class InputIterator2, class Compare>
  bool includes (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2, 
                 Compare comp);

  template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result);

  template <class InputIterator1, class InputIterator2, class OutputIterator,
  class Compare>
  OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result, Compare comp);

  template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result);

  template <class InputIterator1, class InputIterator2, class OutputIterator,
  class Compare>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result, Compare comp);

  template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result);

  template <class InputIterator1, class InputIterator2, class OutputIterator, 
  class Compare>
  OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2, 
                                 OutputIterator result, Compare comp);

  template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_symmetric_difference (InputIterator1 first1,
                                           InputIterator1 last1,
                                           InputIterator2 first2,
                                           InputIterator2 last2,
                                           OutputIterator result);

  template <class InputIterator1, class InputIterator2, class OutputIterator,
  class Compare>
  OutputIterator set_symmetric_difference (InputIterator1 first1,
                                           InputIterator1 last1,
                                           InputIterator2 first2,
                                           InputIterator2 last2,
                                           OutputIterator result, 
                                           Compare comp);





  template <class RandomAccessIterator, class Distance, class T>
  void _RWpush_heap (RandomAccessIterator first, Distance holeIndex,
                    Distance topIndex, T value);

  template <class RandomAccessIterator, class Distance, class T>
  inline void _RWpush_heap_aux (RandomAccessIterator first,
                               RandomAccessIterator last, Distance*, T*)
  {
    _RWpush_heap(first, Distance((last-first)-1), Distance(0), T(*(last-1)));
  }

  template <class RandomAccessIterator>
  inline void push_heap (RandomAccessIterator first, RandomAccessIterator last)
  {
    if (!(first == last))
      _RWpush_heap_aux(first, last, _RWdistance_type(first),
                      _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class Distance, class T, class Compare>
  void _RWpush_heap (RandomAccessIterator first, Distance holeIndex,
                    Distance topIndex, T value, Compare comp);

  template <class RandomAccessIterator, class Compare,  class Distance, class T>
  inline void _RWpush_heap_aux (RandomAccessIterator first,
                               RandomAccessIterator last, Compare comp,
                               Distance*, T*)
  {
    _RWpush_heap(first, Distance((last-first)-1), Distance(0),
                T(*(last - 1)), comp);
  }

  template <class RandomAccessIterator, class Compare>
  inline void push_heap (RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp)
  {
    if (!(first == last))
      _RWpush_heap_aux(first, last, comp, _RWdistance_type(first),
                      _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class Distance, class T>
  void _RWadjust_heap (RandomAccessIterator first, Distance holeIndex,
                      Distance len, T value);

  template <class RandomAccessIterator, class T, class Distance>
  inline void _RWpop_heap (RandomAccessIterator first, RandomAccessIterator last,
                          RandomAccessIterator result, T value, Distance*)
  {
    *result = *first;
    _RWadjust_heap(first, Distance(0), Distance(last - first), value);
  }

  template <class RandomAccessIterator, class T>
  inline void _RWpop_heap_aux (RandomAccessIterator first,
                              RandomAccessIterator last, T*)
  {
    _RWpop_heap(first, last-1, last-1, T(*(last-1)), _RWdistance_type(first));
  }

  template <class RandomAccessIterator>
  inline void pop_heap (RandomAccessIterator first, RandomAccessIterator last)
  {
    if (!(first == last))
      _RWpop_heap_aux(first, last, _RWvalue_type(first));
  }

  template <class RandomAccessIterator, class Distance, class T, class Compare>
  void _RWadjust_heap (RandomAccessIterator first, Distance holeIndex,
                      Distance len, T value, Compare comp);

  template <class RandomAccessIterator, class T, class Compare, class Distance>
  inline void _RWpop_heap (RandomAccessIterator first, RandomAccessIterator last,
                          RandomAccessIterator result, T value, Compare comp,
                          Distance*)
  {
    *result = *first;
    _RWadjust_heap(first, Distance(0), Distance(last - first), value, comp);
  }

  template <class RandomAccessIterator, class T, class Compare>
  inline void _RWpop_heap_aux (RandomAccessIterator first,
                              RandomAccessIterator last, T*, Compare comp)
  {
    _RWpop_heap(first, last - 1, last - 1, T(*(last - 1)), comp,
               _RWdistance_type(first));
  }

  template <class RandomAccessIterator, class Compare>
  inline void pop_heap (RandomAccessIterator first, RandomAccessIterator last,
                        Compare comp)
  {
    if (!(first == last))
      _RWpop_heap_aux(first, last, _RWvalue_type(first), comp);
  }

  template <class RandomAccessIterator, class T, class Distance>
  void _RWmake_heap (RandomAccessIterator first, RandomAccessIterator last, T*,
                    Distance*);

  template <class RandomAccessIterator>
  inline void make_heap (RandomAccessIterator first, RandomAccessIterator last)
  {
    if (!(last - first < 2))
      _RWmake_heap(first, last, _RWvalue_type(first),
                  _RWdistance_type(first));
  }

  template <class RandomAccessIterator, class Compare, class T, class Distance>
  void _RWmake_heap (RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp, T*, Distance*);

  template <class RandomAccessIterator, class Compare>
  inline void make_heap (RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp)
  {
    if (!(last - first < 2))
      _RWmake_heap(first, last, comp, _RWvalue_type(first),
                  _RWdistance_type(first));
  }

  template <class RandomAccessIterator>
  void sort_heap (RandomAccessIterator first, RandomAccessIterator last);

  template <class RandomAccessIterator, class Compare>
  void sort_heap (RandomAccessIterator first, RandomAccessIterator last,
                  Compare comp);

#line 1770 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/algorithm"

  template <class ForwardIterator>
  ForwardIterator min_element (ForwardIterator first, ForwardIterator last);

  template <class ForwardIterator, class Compare>
  ForwardIterator min_element (ForwardIterator first, ForwardIterator last,
                               Compare comp);

  template <class ForwardIterator>
  ForwardIterator max_element (ForwardIterator first, ForwardIterator last);

  template <class ForwardIterator, class Compare>
  ForwardIterator max_element (ForwardIterator first, ForwardIterator last,
                               Compare comp);

  template <class InputIterator1, class InputIterator2>
  bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2);

  template <class InputIterator1, class InputIterator2, class Compare>
  bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               Compare comp);





  template <class BidirectionalIterator>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last);

  template <class BidirectionalIterator, class Compare>
  bool next_permutation (BidirectionalIterator first, BidirectionalIterator last,
                         Compare comp);

  template <class BidirectionalIterator>
  bool prev_permutation (BidirectionalIterator first,
                         BidirectionalIterator last);

  template <class BidirectionalIterator, class Compare>
  bool prev_permutation (BidirectionalIterator first, BidirectionalIterator last,
                         Compare comp);


}












#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 5 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/throw_exception.hpp"
























namespace boost
{







template<class E> void throw_exception(E const & e)
{
    throw e;
}



} 

#line 6 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"


















#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"




















































 



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"


















































 




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"



















 
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 24 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"





















































 






#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"










 





#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"










 

using std::btowc;


using std::fwscanf;
using std::fwprintf;
using std::fgetwc;
using std::fgetws;
using std::fputwc;
using std::fputws;
using std::getwc;
using std::putwc;
using std::fwide;
using std::ungetwc;

using std::vfwprintf;



using std::vswprintf;
using std::vwprintf;


using std::getwchar;
using std::mbrlen;
using std::mbrtowc;
using std::mbsinit;
using std::mbsrtowcs;
using std::mbstate_t;
using std::putwchar;
using std::size_t;
using std::swprintf;
using std::swscanf;
using std::wcrtomb;
using std::wcscat;
using std::wcschr;
using std::wcscmp;
using std::wcscoll;
using std::wcscpy;
using std::wcscspn;



using std::wcslen;
using std::wcsncat;
using std::wcsncmp;
using std::wcsncpy;
using std::wcspbrk;
using std::wcsrchr;
using std::wcsrtombs;
using std::wcsspn;
using std::wcsstr;
using std::wcstod;



using std::wcstol;
using std::wcstoul;
using std::wcsxfrm;
using std::wctob;
using std::wint_t;
using std::wmemchr;
using std::wmemcmp;
using std::wmemcpy;
using std::wmemmove;
using std::wmemset;
using std::wprintf;
using std::wscanf;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 36 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 65 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"





#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










namespace std {


  template<class charT> struct  char_traits;

  template <class T> class  allocator;

  template <class stateT> class  fpos;





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

  typedef long streamoff;
  typedef long wstreamoff;


}






#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"





















































 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstring"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cstring"










 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 59 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"















 
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iotraits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iotraits"




















































 






#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 61 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iotraits"



#      pragma __environment __save
#      pragma __environment __cxx_header_defaults









namespace std {


  

 

#line 118 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iotraits"

  

 

  


 

  template <class stateT>
  class  fpos
  {
  public:
    
    
    
    typedef stateT  state_type;
      
    inline fpos(long off = 0);



    inline fpos(long, fpos_t, state_type);





    inline bool good();
    inline operator long() const;

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

    inline long         offset() const;
    inline long         offset (long);

    inline state_type   state () const;


    inline void state (state_type);









    inline fpos_t         pos(fpos_t);
    inline fpos_t         pos() const; 

                            
    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               _RWpos;     



    fpos_t             _RWfp ;     

    state_type         _RWstate;   
    bool               _RWstatus;  
  };


  

 

  

 

  template <class stateT>
  inline
  fpos<stateT>::fpos(long off)
  : _RWpos(off)



  , _RWfp(fpos_t(0))

  , _RWstate(stateT()) 
  , _RWstatus(true)
  {
    if ( off == -1 ) _RWstatus = false;
  }

  

 

#line 272 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iotraits"

  

 

  template <class stateT>
  inline



  fpos<stateT>::fpos(long off,fpos_t fposit,state_type state)

  : _RWpos(off)
  , _RWfp(fposit)
  , _RWstate(state)
  , _RWstatus(true)
  { ; }
 
  

 

  template <class stateT> 
  inline
  fpos<stateT>::fpos(const fpos<stateT>& str_pos)
  {
    _RWpos   = str_pos._RWpos;
    _RWfp    = str_pos._RWfp;
    _RWstate = str_pos._RWstate;
    _RWstatus = str_pos._RWstatus;      
  }

  

 

  template <class stateT>
  inline long 
  fpos<stateT>::offset(long off)
  {
    long var=_RWpos;
    _RWpos = off; 
    return var;
  }

  

 

  template <class stateT>




  inline fpos_t
  fpos<stateT>::pos(fpos_t posi)

  {
    long var=_RWfp;
    _RWfp = posi;
    return var;
  }

  

 

  template <class stateT>

  inline void



  fpos<stateT>::state(state_type state)
  {




    _RWstate = state;




  }

  

 

  template <class stateT>
  inline bool 
  fpos<stateT>::good() 
  {
    return _RWstatus;
  }

  

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

  

 

  template <class stateT>
  inline fpos<stateT>& 
  fpos<stateT>::operator=(const fpos<stateT>& str_pos)
  {
    if ( &str_pos != this )
    {
      _RWpos    = str_pos._RWpos;
      _RWfp     = str_pos._RWfp;
      _RWstate  = str_pos._RWstate;
      _RWstatus = str_pos._RWstatus;
    }
    return *this;
  }

  

 

  template <class stateT>



  inline fpos_t

  fpos<stateT>::pos() const
  {
    return _RWfp;
  }

  

 

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

  

 

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

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

  

 

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

 

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



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

  

 

  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 ( (_RWpos+_RWfp) < (pos._RWpos + pos._RWfp) );
  }

  

 

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

  

 

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

  

 

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

  

 

  template <class stateT>
  inline bool 
  fpos<stateT>::operator==(const int& pos) const
  { 
    return (  (_RWpos+_RWfp) == 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 ( (_RWpos+_RWfp) < pos );
  }

  

 

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

  

 

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

  

 

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

  

 

  template <class stateT>
  inline bool 
  fpos<stateT>::operator==(const long& pos) const
  { 
    return (  (_RWpos+_RWfp) == 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 ( (_RWpos+_RWfp) < pos );
  }

  

 

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

  

 

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

  

 

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


}








#      pragma __environment __restore





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 77 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"





#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










namespace std {



  

 

  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 arg_n, const char_type& a)



    {

      int n = arg_n;

      while (n-- > 0 && *s != a) 
        ++s;
      return  n >= 0 ? 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, const 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); }


  };






 

  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);
#line 282 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"
      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, const 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); }


  };






 




  template< >  
  struct  char_traits<wchar_t> 
  {
    typedef wchar_t                   char_type;


    typedef wint_t                    int_type;









    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)
    {

      return memcmp(s1, s2, n*sizeof(char_type));
#line 388 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"
    }


    static size_t length(const char_type *s)
    {

      return wcslen(s);





    }
 

    static const char_type* find (const char_type* s, size_t arg_n,



                                  const char_type& a)
    {

       int n = arg_n;


      return (char_type*) wmemchr(s,a,n);





    }

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

      memmove(s1, s2, n*sizeof(char_type));
#line 436 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/traits"
      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, const char_type a)



    {

      wmemset(s,a,n);





      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 _RWrwstd {






  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 0L;
    }

    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 0L;       
    }

    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++)
      {

	size_t xpos = p - s; 
        bool found = false;

        for (const charT* q = v; *q; q++)

        {
                if (traits::eq(*p, *q))
                {
                  found = true;
                  break;
                }
        }
        if (!found)
          return xpos;
      }





      return  p-s;
    }
  };

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

    { return std::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 0L;       
    }
    static size_t find_first_of(const char* s, const char* v)

    { return std::strcspn(s,v); }



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

    { return std::strspn(s,v); }



  };


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

    { return std::wcsstr(s,v); }



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

    { return std::wcscspn(s,v); }



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

    { return std::wcsspn(s,v); }



  };



}








#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 110 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"







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;
#line 175 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"


  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;
#line 235 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/iosfwd"


}








#      pragma __environment __restore





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 26 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"










 





#line 33 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar_ansi_impl"










 

using std::btowc;


using std::fwscanf;
using std::fwprintf;
using std::fgetwc;
using std::fgetws;
using std::fputwc;
using std::fputws;
using std::getwc;
using std::putwc;
using std::fwide;
using std::ungetwc;

using std::vfwprintf;



using std::vswprintf;
using std::vwprintf;


using std::getwchar;
using std::mbrlen;
using std::mbrtowc;
using std::mbsinit;
using std::mbsrtowcs;
using std::mbstate_t;
using std::putwchar;
using std::size_t;
using std::swprintf;
using std::swscanf;
using std::wcrtomb;
using std::wcscat;
using std::wcschr;
using std::wcscmp;
using std::wcscoll;
using std::wcscpy;
using std::wcscspn;



using std::wcslen;
using std::wcsncat;
using std::wcsncmp;
using std::wcsncpy;
using std::wcspbrk;
using std::wcsrchr;
using std::wcsrtombs;
using std::wcsspn;
using std::wcsstr;
using std::wcstod;



using std::wcstol;
using std::wcstoul;
using std::wcsxfrm;
using std::wctob;
using std::wint_t;
using std::wmemchr;
using std::wmemcmp;
using std::wmemcpy;
using std::wmemmove;
using std::wmemset;
using std::wprintf;
using std::wscanf;
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 36 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wchar.h"




#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float.h"










 







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float_cname_impl"










 




 







































 



 






 

#line 78 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float_cname_impl"



 

#line 92 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float_cname_impl"



 



#line 108 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float_cname_impl"

#line 122 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float_cname_impl"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 23 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/float.h"







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 29 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"



#   pragma __environment __save
#   pragma __environment __cxx_header_defaults















#line 55 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"







namespace _Compaqimpl {
  extern "C" unsigned   int read_rnd(void);
#line 74 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
}     











#line 94 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"



namespace std {






    enum float_round_style {
      round_indeterminate       = -1,
      round_toward_zero         =  0,
      round_to_nearest          =  1,
      round_toward_infinity     =  2,
      round_toward_neg_infinity =  3
    };

    enum float_denorm_style {
      denorm_indeterminate      = -1,
      denorm_absent             =  0,
      denorm_present            =  1
    };







    template<class T> class numeric_limits {
    public:
      static const bool is_specialized = false;
      inline static T min() throw() {return (T) 0;}
      inline static T max() throw() {return (T) 0;}
      static const int digits = 0;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 0;
      inline static T epsilon() throw() {return (T) 0;}
      inline static T round_error() throw() {return (T) 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;
      inline static T infinity() throw() {return (T) 0;}
      inline static T quiet_NaN() throw() {return (T) 0;}
      inline static T signaling_NaN() throw() {return (T) 0;}
      inline static T denorm_min() throw() {return (T) 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = false;
      static const bool is_modulo = false;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };





template <class T>
    const bool numeric_limits<T>::is_specialized;
template <class T>
    const int numeric_limits<T>::digits;
template <class T>
    const int numeric_limits<T>::digits10;
template <class T>
    const bool numeric_limits<T>::is_signed;
template <class T>  
    const bool numeric_limits<T>::is_integer;
template <class T>
    const bool numeric_limits<T>::is_exact;
template <class T>
    const int numeric_limits<T>::radix;
template <class T>
    const int numeric_limits<T>::min_exponent;
template <class T>
    const int numeric_limits<T>::min_exponent10;
template <class T>
    const int numeric_limits<T>::max_exponent;
template <class T>
    const int numeric_limits<T>::max_exponent10;
template <class T>
    const bool numeric_limits<T>::has_infinity;
template <class T>
    const bool numeric_limits<T>::has_quiet_NaN;
template <class T>
    const bool numeric_limits<T>::has_signaling_NaN;
template <class T>
    const float_denorm_style numeric_limits<T>::has_denorm;
template <class T>
    const bool numeric_limits<T>::has_denorm_loss;
template <class T>
    const bool numeric_limits<T>::is_iec559;
template <class T>
    const bool numeric_limits<T>::is_bounded;
template <class T>
    const bool numeric_limits<T>::is_modulo;
template <class T>
    const bool numeric_limits<T>::traps;
template <class T>
    const bool numeric_limits<T>::tinyness_before;
template <class T>
    const float_round_style numeric_limits<T>::round_style;







template <>

    class numeric_limits<bool> {
    public:
      static const bool is_specialized = true;
      inline static bool min() throw() {return false;}
      inline static bool max() throw() {return true;}
      static const int digits = 1;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static int epsilon() throw() {return 0;}
      inline static int round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static int infinity() throw() {return 0;}
      inline static int quiet_NaN() throw() {return 0;}
      inline static int signaling_NaN() throw() {return 0;}
      inline static int denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };







template <>

class numeric_limits<char> {
    public:
      static const bool is_specialized = true;
      inline static char min() throw() {return (-128);}
      inline static char max() throw() {return 127;}
      static const int digits = 8 * sizeof(char) - 1;
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static char epsilon() throw() {return 0;}
      inline static char round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static char infinity() throw() {return 0;}
      inline static char quiet_NaN() throw() {return 0;}
      inline static char signaling_NaN() throw() {return 0;}
      inline static char denorm_min() throw() {return 0;}
      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;
      inline static signed char min() throw() {return (-128);}
      inline static signed char max() throw() {return 127;}
      static const int digits =
             8 * sizeof(signed char) - 1;
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static signed char epsilon() throw() {return 0;}
      inline static signed char round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static signed char infinity() throw() {return 0;}
      inline static signed char quiet_NaN() throw() {return 0;}
      inline static signed char signaling_NaN() throw() {return 0;}
      inline static signed char denorm_min() throw() {return 0;}
      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 char> {
    public:
      static const bool is_specialized = true;
      inline static unsigned char min() throw() {return 0;}
      inline static unsigned char max() throw() {return 255U;}
      static const int digits = 
            8 * sizeof(unsigned char);
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned char epsilon() throw() {return 0;}
      inline static unsigned char round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static unsigned char infinity() throw() {return 0;}
      inline static unsigned char quiet_NaN() throw() {return 0;}
      inline static unsigned char signaling_NaN() throw() {return 0;}
      inline static unsigned char denorm_min() throw() {return 0;}
      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<wchar_t> {
    public:
      static const bool is_specialized = true;
      inline static wchar_t min() throw() {return 0;}
      inline static wchar_t max() throw() {return ((wchar_t)~0);}
      static const int digits = 8 * sizeof(wchar_t);
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static wchar_t epsilon() throw() {return 0;}
      inline static wchar_t round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static wchar_t infinity() throw() {return 0;}
      inline static wchar_t quiet_NaN() throw() {return 0;}
      inline static wchar_t signaling_NaN() throw() {return 0;}
      inline static wchar_t denorm_min() throw() {return 0;}
      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<short> {
    public:
      static const bool is_specialized = true;
      inline static short min() throw() {return (-32768);}
      inline static short max() throw() {return 32767;}
      static const int digits = 8 * sizeof(short) - 1;
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static short epsilon() throw() {return 0;}
      inline static short round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static short infinity() throw() {return 0;}
      inline static short quiet_NaN() throw() {return 0;}
      inline static short signaling_NaN() throw() {return 0;}
      inline static short denorm_min() throw() {return 0;}
      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<int> {
    public:
      static const bool is_specialized = true;
      inline static int min() throw() {return (-2147483647-1);}
      inline static int max() throw() {return 2147483647;}
      static const int digits = 8 * sizeof(int) - 1;
      static const int digits10 =

            (digits*301)/1000;



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static int epsilon() throw() {return 0;}
      inline static int round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static int infinity() throw() {return 0;}
      inline static int quiet_NaN() throw() {return 0;}
      inline static int signaling_NaN() throw() {return 0;}
      inline static int denorm_min() throw() {return 0;}
      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;
      inline static long min() throw() {return (-9223372036854775807-1);}
      inline static long max() throw() {return 9223372036854775807;}
      static const int digits = 8 * sizeof(long) - 1;
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static long epsilon() throw() {return 0;}
      inline static long round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static long infinity() throw() {return 0;}
      inline static long quiet_NaN() throw() {return 0;}
      inline static long signaling_NaN() throw() {return 0;}
      inline static long denorm_min() throw() {return 0;}
      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;
    };


#line 671 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"





template <>

class numeric_limits<unsigned short> {
    public:
      static const bool is_specialized = true;
      inline static unsigned short min() throw() {return 0;}
      inline static unsigned short max() throw() {return 65535U;}
      static const int digits = 
            8 * sizeof(unsigned short);
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned short epsilon() throw() {return 0;}
      inline static unsigned short round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static unsigned short infinity() throw() {return 0;}
      inline static unsigned short quiet_NaN() throw() {return 0;}
      inline static unsigned short signaling_NaN() throw() {return 0;}
      inline static unsigned short denorm_min() throw() {return 0;}
      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;
      inline static unsigned int min() throw() {return 0;}
      inline static unsigned int max() throw() {return 4294967295U;}
      static const int digits =    
            8 * sizeof(unsigned int);
      static const int digits10 =

            (digits*301)/1000;



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned int epsilon() throw() {return 0;}
      inline static unsigned int round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static unsigned int infinity() throw() {return 0;}
      inline static unsigned int quiet_NaN() throw() {return 0;}
      inline static unsigned int signaling_NaN() throw() {return 0;}
      inline static unsigned int denorm_min() throw() {return 0;}
      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 long> {
    public:
      static const bool is_specialized = true;
      inline static unsigned long min() throw() {return 0;}
      inline static unsigned long max() throw() {return 18446744073709551615U;}
      static const int digits =
            8 * sizeof(unsigned long);
      static const int digits10 = 

            (digits*301)/1000;



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned long epsilon() throw() {return 0;}
      inline static unsigned long round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static unsigned long infinity() throw() {return 0;}
      inline static unsigned long quiet_NaN() throw() {return 0;}
      inline static unsigned long signaling_NaN() throw() {return 0;}
      inline static unsigned long denorm_min() throw() {return 0;}
      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<float> {
    public:
      static const bool is_specialized = true;
      inline static float min() throw() {return 1.17549435e-38f;}
      inline static float max() throw() {return 3.40282347e+38f;}
      static const int digits = 24;
      static const int digits10 = 6;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      inline static float epsilon() throw() {return 1.19209290e-07f;}
      inline static float round_error() throw() {
          int rounding = 1;

          if (rounding == round_indeterminate)

              rounding = (int)_Compaqimpl::read_rnd();




          switch (rounding) {
              case round_toward_zero:
              case round_toward_infinity:
              case round_toward_neg_infinity:
                  return 1.0F;
              default: 
                  return 0.5F;
          };
      } 
      static const int min_exponent = -125;
      static const int min_exponent10 = -37;
      static const int max_exponent = 128;
      static const int max_exponent10 = 38;

      static const bool has_infinity = 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;
      inline static float infinity() throw() {return 0;}
      inline static float quiet_NaN() throw() {return 0;}
      inline static float signaling_NaN() throw() {return 0;}
      inline static float denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
#line 893 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = 
            (float_round_style)1;
    };






template <>

class numeric_limits<double> {
    public:
      static const bool is_specialized = true;
      inline static double min() throw() {return 2.2250738585072014e-308;}
      inline static double max() throw() {return 1.79769313486231570e+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;
      inline static double epsilon() throw() {return 2.2204460492503131e-16;}
      inline static double round_error() throw() {
          int rounding = 1;

          if (rounding == round_indeterminate)

              rounding = (int)_Compaqimpl::read_rnd();




          switch (rounding) {
              case round_toward_zero:
              case round_toward_infinity:
              case round_toward_neg_infinity:
                  return 1.0F;
              default: 
                  return 0.5F;
          };
      } 
      static const int min_exponent = -1021;
      static const int min_exponent10 = -307;
      static const int max_exponent = 1024;
      static const int max_exponent10 = 308;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static double infinity() throw() {return 0;}
      inline static double quiet_NaN() throw() {return 0;}
      inline static double signaling_NaN() throw() {return 0;}
      inline static double denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
#line 981 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style =
           (float_round_style)1;
    };






template <>

class numeric_limits<long double> {
    public:
      static const bool is_specialized = true;
      inline static long double min() throw() {return 3.3621031431120935062626778173217526026e-4932L;}
      inline static long double max() throw() {return 1.1897314953572317650857593266280070162e+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;
      inline static long double epsilon() throw() {return 1.9259299443872358530559779425849273185e-34L;}
      inline static long double round_error() throw() {
          int rounding = 1;

          if (rounding == round_indeterminate)

              rounding = (int)_Compaqimpl::read_rnd();




          switch (rounding) {
              case round_toward_zero:
              case round_toward_infinity:
              case round_toward_neg_infinity:
                  return 1.0F;
              default: 
                  return 0.5F;
          };
      } 
      static const int min_exponent = -16381;
      static const int min_exponent10 = -4931;
      static const int max_exponent = 16384;
      static const int max_exponent10 = 4932;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      inline static long double infinity() throw() {return 0;}
      inline static long double quiet_NaN() throw() {return 0;}
      inline static long double signaling_NaN() throw() {return 0;}
      inline static long double denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
#line 1084 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/limits"
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = 
            (float_round_style)1;
    };


}











#   pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 59 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cctype"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cctype"










 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 65 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cwchar"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cwchar"










 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 73 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cwctype"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cwctype"










 








#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wctype_cname_impl"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wctype_cname_impl"










 

#line 19 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/wctype_cname_impl"

extern "C" {
namespace std {

typedef unsigned long wctrans_t;

typedef unsigned int wctype_t;

typedef unsigned int wint_t;          



extern int	iswalpha (wint_t);
extern int	iswalnum (wint_t);
extern int	iswcntrl (wint_t);
extern int	iswdigit (wint_t);
extern int	iswgraph (wint_t);
extern int	iswlower (wint_t);
extern int	iswprint (wint_t);
extern int	iswpunct (wint_t);
extern int	iswspace (wint_t);
extern int	iswupper (wint_t);
extern int	iswxdigit (wint_t);
extern wint_t    towctrans (wint_t, wctrans_t);
extern wint_t	towupper (wint_t);
extern wint_t	towlower (wint_t);
extern wctrans_t wctrans (const char *);
extern int	iswctype (wint_t, wctype_t);
extern wctype_t	wctype (const char *);


}    
}    

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 22 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cwctype"


#line 31 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/cwctype"

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 74 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
#line 83 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"





#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"


















































 












#      pragma __environment __save
#      pragma __environment __cxx_header_defaults











#line 1 "/usr/include/machine/builtins.h"


















 


 


 





 







extern "C" {



#pragma __nostandard


























 




 
int  __ATOMIC_ADD_LONG(volatile void *__address, int __expression);
int  __ATOMIC_ADD_LONG_RETRY(volatile void *__address,
			     int __expression,
			     int __retry,
			     int *__status);
long  __ATOMIC_ADD_QUAD(volatile void *__address, long __expression);
long  __ATOMIC_ADD_QUAD_RETRY(volatile void *__address,
			      long __expression,
			      int __retry,
			      int *__status);

int  __ATOMIC_AND_LONG(volatile void *__address, int __expression);
int  __ATOMIC_AND_LONG_RETRY(volatile void *__address,
			     int __expression,
			     int __retry,
			     int *__status);
long  __ATOMIC_AND_QUAD(volatile void *__address, long __expression);
long  __ATOMIC_AND_QUAD_RETRY(volatile void *__address,
			      long __expression,
			      int __retry,
			      int *__status);

int  __ATOMIC_OR_LONG(volatile void *__address, int __expression);
int  __ATOMIC_OR_LONG_RETRY(volatile void *__address,
			    int __expression,
			    int __retry,
			    int *__status);
long  __ATOMIC_OR_QUAD(volatile void *__address, long __expression);
long  __ATOMIC_OR_QUAD_RETRY(volatile void *__address,
			     long __expression,
			     int __retry,
			     int *__status);



 
int  __ATOMIC_INCREMENT_LONG(volatile void *__address);
long  __ATOMIC_INCREMENT_QUAD(volatile void *__address);

int  __ATOMIC_DECREMENT_LONG(volatile void *__address);
long  __ATOMIC_DECREMENT_QUAD(volatile void *__address);




 
int  __ATOMIC_EXCH_LONG(volatile void *__address, int __expression);
int  __ATOMIC_EXCH_LONG_RETRY(volatile void *__address,
			      int __expression,
			      int __retry,
			      int *__status);
long  __ATOMIC_EXCH_QUAD(volatile void *__address, long __expression);
long  __ATOMIC_EXCH_QUAD_RETRY(volatile void *__address,
			       long __expression,
			       int __retry,
			       int *__status);




 
int __INTERLOCKED_TESTBITCC_QUAD(volatile void *__address, int __bit_position);
int __INTERLOCKED_TESTBITCC_QUAD_RETRY(volatile void *__address,
				       int __bit_position,
				       int __retry,
				       int *__status);



 
int __INTERLOCKED_TESTBITSS_QUAD(volatile void *__address, int __bit_position);
int __INTERLOCKED_TESTBITSS_QUAD_RETRY(volatile void *__address,
				       int __bit_position,
				       int __retry,
				       int *__status);





 
void __LOCK_LONG(volatile void *__address);
int  __LOCK_LONG_RETRY(volatile void *__address, int __retry);
void __UNLOCK_LONG(volatile void *__address);






 
void __ACQUIRE_SEM_LONG(volatile void *__address);
int  __ACQUIRE_SEM_LONG_RETRY(volatile void *__address, int __retry);
void __RELEASE_SEM_LONG(volatile void *__address);






 
int __CMP_STORE_LONG(volatile void *__source,
		     int __old_value,
		     int __new_value,
		     volatile void *__dest);
int __CMP_STORE_QUAD(volatile void *__source,
		     signed long __old_value,
		     signed long __new_value,
		     volatile void  *__dest);





 
int __ADAWI(short __src, volatile short *__dest);













 

long _popcnt(unsigned long);
long _poppar(unsigned long);
long _leadz(unsigned long);
long _trailz(unsigned long);
#pragma intrinsic(_popcnt, _poppar, _leadz, _trailz)




















 




 
int __ADD_ATOMIC_LONG(volatile void *__address, int __expression, ...);
int __ADD_ATOMIC_QUAD(volatile void *__address, int __expression, ...);

int __AND_ATOMIC_LONG(volatile void *__address, int __expression, ...);
int __AND_ATOMIC_QUAD(volatile void *__address, int __expression, ...);

int __OR_ATOMIC_LONG(volatile void *__address, int __expression, ...);
int __OR_ATOMIC_QUAD(volatile void *__address, int __expression, ...);





 
int __TESTBITCCI(volatile void *__address, int __position, ...);
int __TESTBITSSI(volatile void *__address, int __position, ...);












 



 
void	__MB(void);



 
void	__PAL_IMB(void);



 
void __TRAPB(void);



 
unsigned long __RPCC(void);



 
void __PAL_GENTRAP(unsigned long __encoded_software_trap);



 
void __PAL_BPT(void);



 
void __PAL_BUGCHK(unsigned long __bugchk_code);



 
void __PAL_SWPCTX(void *__address);



 
void __PAL_HALT(void);



 
unsigned long __UMULH(unsigned long __oper1,
			 unsigned long __oper2);






 


 
float	    __CPYSF(float __operand1, float __operand2);
double	    __CPYS(double __operand1, double __operand2);



 
float	    __CPYSNF(float __operand1, float __operand2);
double	    __CPYSN(double __operand1, double __operand2);



 
float	    __CPYSEF(float __operand1, float __operand2);
double	    __CPYSE(double __operand1, double __operand2);



 
signed long __CVTTQ(double __operand1);



 
float __CVTTS_C(double __operand1);



 
float __ADDS_C(float __operand1, float __operand2);
double __ADDT_C(double __operand1, double __operand2);



 
float __SUBS_C(float __operand1, float __operand2);
double __SUBT_C(double __operand1, double __operand2);



 
float __MULS_C(float __operand1, float __operand2);
double __MULT_C(double __operand1, double __operand2);



 
float __DIVS_C(float __operand1, float __operand2);
double __DIVT_C(double __operand1, double __operand2);









 
void *__ALLOCA(unsigned int __x);


#pragma __standard


}


#line 78 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"






#line 92 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"

#line 116 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"







namespace std {





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


} namespace _RWrwstd {


  
  
  
  
  
  
  
  
  
  
  

  template <class Allocator>
  class  _RWstring_noref_rep
  {
  public:
     explicit _RWstring_noref_rep(long refs = 0)
      : _RWrefs_((bool)refs), _RWcapacity_(0), _RWnchars_(0)  {;}
    _RWstring_noref_rep(const _RWstring_noref_rep& r)
      : _RWrefs_((bool)r._RWrefs_), _RWcapacity_(0), _RWnchars_(0)  {;}
  
    typedef Allocator                        allocator_type;
    typedef typename allocator_type::size_type size_type;

  protected:





    size_type       _RWcapacity_;  
    size_type       _RWnchars_;    

    bool            _RWrefs_;      

  };

  template <class charT, class traits , class Allocator>
  class  _RWstring_noref
   : public _RWstring_noref_rep<Allocator>
  {
  public:
    typedef _RWstring_noref_rep<Allocator> _RWstring_ref_rep_type;
    typedef typename _RWstring_noref_rep<Allocator>::size_type size_type;
  
    explicit _RWstring_noref (long=0) 
    { ; }
    _RWstring_noref (const _RWstring_noref<charT,traits,Allocator>& ref)
    { ; }
    ~_RWstring_noref() { ; }

  private:
    long _RWreferences () const
    { 
      return (long)_RWstring_noref_rep<Allocator>::_RWrefs_; 
    }
    void _RWsetRefCount (long r)
    { ; }
    void _RWaddReference ()
    { ; }
    long  _RWremoveReference ()
    { 
      return (long)_RWstring_noref_rep<Allocator>::_RWrefs_;
    }
    size_type length () const
    { 
      return _RWstring_noref_rep<Allocator>::_RWnchars_; 
    }
    size_type _RWgetCapac () const
    { 
      return _RWstring_noref_rep<Allocator>::_RWcapacity_;
    }
    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>;



  };


  
  
  
  
  
  






  template <class Allocator>
  class  _RWstring_ref_rep
  {
  public:
    
    
    
  
    _RWstring_ref_rep()
      : _RWrefs_(0), _RWcapacity_(0), _RWnchars_(0) {;}
    _RWstring_ref_rep(long x)
      : _RWrefs_(x), _RWcapacity_(0), _RWnchars_(0) {;}
    _RWstring_ref_rep(const _RWstring_ref_rep& r)
      : _RWrefs_(r._RWrefs_), _RWcapacity_(0), _RWnchars_(0)  {;}
  
    typedef Allocator                        allocator_type;
    typedef typename allocator_type::size_type size_type;

  protected:





    long   _RWrefs_;               
                                  
    size_type       _RWcapacity_;  
    size_type       _RWnchars_;    
  };


  template <class charT, class traits , class Allocator >
  class  _RWstring_ref : public _RWstring_ref_rep<Allocator>
  {
  public:
    typedef _RWstring_ref_rep<Allocator> _RWstring_ref_rep_type;
    typedef typename _RWstring_ref_rep<Allocator>::size_type size_type;
  
    explicit _RWstring_ref (long initRef = 0) 
      :  _RWstring_ref_rep<Allocator>(initRef - 1)
    { ; }

    _RWstring_ref (const _RWstring_ref<charT,traits,Allocator>& ref)
      : _RWstring_ref_rep<Allocator>(ref._RWrefs_)
    { ; }
    ~_RWstring_ref() { ; }

  private:
    long _RWreferences () const 
    { 
      return _RWstring_ref_rep<Allocator>::_RWrefs_+1; 
    }

    void _RWsetRefCount (long r)       
    { 
      if (this != std::basic_string<charT,traits,Allocator>::_RWgetNullRep())
      {
#line 307 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"
        __MB(), __ATOMIC_EXCH_QUAD(&this->_RWrefs_,r-1), __MB();
      }
    }

    void _RWaddReference ()
    { 
      if (this != std::basic_string<charT,traits,Allocator>::_RWgetNullRep())
      {
#line 324 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"
        __MB(), __ATOMIC_INCREMENT_QUAD(&this->_RWrefs_), __MB();
      }
    }
    long  _RWremoveReference ()                
    {
      if (this != std::basic_string<charT,traits,Allocator>::_RWgetNullRep())
      {
#line 340 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string_ref"
        return _RWunSafeRemoveReference();
      }
      else
        return 1;
    }
    long  _RWunSafeRemoveReference ()                
    {
      if (this != std::basic_string<charT,traits,Allocator>::_RWgetNullRep())
      {
        __MB(), __ATOMIC_DECREMENT_QUAD(&this->_RWrefs_), __MB();
        return this->_RWrefs_+1;
      }
      else
        return 1;
    }

    size_type length () const
    { return _RWstring_ref_rep<Allocator>::_RWnchars_; }
    size_type _RWgetCapac () const
    { return _RWstring_ref_rep<Allocator>::_RWcapacity_;}

    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>;



  };


  
  
  
  
  
  

  template <class charT, class traits , class Allocator, 
            class stringRef = _RWstring_ref_rep<Allocator> >
  struct  _RWnull_string_ref_rep
  {
    
    
    
    stringRef      _RWref_hdr_;
    charT          _RWeos_char_; 

    _RWnull_string_ref_rep ()
      : _RWref_hdr_(1), _RWeos_char_(charT(0)) {;}
    _RWnull_string_ref_rep (const _RWnull_string_ref_rep<charT,traits, 
                                                       Allocator,stringRef>& r)
      : _RWref_hdr_(r._RWref_hdr_), _RWeos_char_(charT(0)) {;}

  };


} 








#      pragma __environment __restore






#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 89 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"




#      pragma __environment __save
#      pragma __environment __cxx_header_defaults










namespace _RWrwstd {




#line 117 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
  extern const char * _RWrwse_InvalidSizeParam;
  extern const char * _RWrwse_PosBeyondEndOfString;
  extern const char * _RWrwse_ResultLenInvalid;
  extern const char * _RWrwse_StringIndexOutOfRange;
  extern const char * _RWrwse_UnexpectedNullPtr;




} namespace std {







  template <class charT, class traits , class Allocator >
  class  basic_string
  {
  public:

    
    
    
    
    
    
    
    

    typedef _RWrwstd::_RWstring_ref<charT,traits,Allocator> _RWstring_ref_type;



    
    
    
    
    typedef typename _RWstring_ref_type::_RWstring_ref_rep_type _RWrep_type;
    
    
    
    
    
    
    typedef _RWrwstd::_RWnull_string_ref_rep<charT,traits,Allocator,_RWrep_type>  _RWnull_ref_type;

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

  private:


    typedef Allocator  _RWvalue_alloc_type;
    typedef typename Allocator::template rebind<_RWstring_ref_type>::other  _RWref_alloc_type;





  
  public:


    typedef typename allocator_type::size_type              size_type;
    typedef typename allocator_type::difference_type              difference_type;
    typedef typename _RWvalue_alloc_type::reference       reference;
    typedef typename _RWvalue_alloc_type::const_reference const_reference;
    typedef typename _RWvalue_alloc_type::pointer         pointer;
    typedef typename _RWvalue_alloc_type::const_pointer   const_pointer;

    typedef charT* iterator;
    typedef const charT* const_iterator;
#line 209 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"


    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef std::reverse_iterator<iterator>  reverse_iterator;
#line 223 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"




    static const size_type npos;


    inline explicit 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());

#line 254 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"


    template <class InputIterator>
    basic_string (InputIterator, InputIterator, const Allocator& = Allocator());
    basic_string (int n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (unsigned int n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (long n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (unsigned long n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (short n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (unsigned short n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (char n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }



    basic_string (unsigned char n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }




    basic_string (wchar_t n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }





    basic_string (bool n, charT c, const Allocator& alloc = Allocator())
      : _RWdata_((charT*)0,alloc)

    { _RWinitn(n,c); }
#line 341 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

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




    ~basic_string ()
    {
      _RWunLink();
    }

    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 () 
    { _RWcow(); _RWpref()->_RWsetRefCount(0); return _RWdata_.data(); }
    const_iterator begin () const  
    { return _RWdata_.data(); }
    iterator end () 
    { _RWcow(); _RWpref()->_RWsetRefCount(0); return _RWdata_.data()+length(); }
    const_iterator end   () const  
    { return _RWdata_.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(_RWrep_type)-2;
    }
    inline void resize (size_type, charT);
    void resize (size_type n)
    {
      resize(n,_RWeos()); 
    }
    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>&);
    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*);


    template<class InputIterator>
    inline basic_string<charT, traits, Allocator>& append (InputIterator,
                                                    InputIterator);


    template<class InputIterator>
    basic_string& append (InputIterator __first, InputIterator __last,
                          const _RWrwstd::__rw_select < false > *) {
        
        
        return replace (end (), end (), __first, __last), *this;
    }

    basic_string& append (size_type __n, value_type __c,
                          const _RWrwstd::__rw_select < true > *) {
        
        return replace (size (), 0, __n, __c);
    }

    basic_string<charT, traits, Allocator>& append (int n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (unsigned int n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (long n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (unsigned long n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (short n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (unsigned short n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (char n, charT c)
    { return replace(length(),0,n,c); }
    basic_string<charT, traits, Allocator>& append (unsigned char n, charT c)
    { return replace(length(),0,n,c); }

    basic_string<charT, traits, Allocator>& append (wchar_t n, charT c)
    { return replace(length(),0,n,c); }


    basic_string<charT, traits, Allocator>& append (bool n, charT c)
    { return replace(length(),0,n,c); }
#line 469 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

    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*);



    template<class InputIterator>
    inline basic_string<charT, traits, Allocator>& assign (InputIterator,
                                                    InputIterator);


    template<class _InputIterator>
    basic_string& assign (_InputIterator __first, _InputIterator __last,
                          const _RWrwstd::__rw_select < false > *) {
        
        
        return replace (begin (), end (), __first, __last);
    }

    basic_string& assign (size_type __n, value_type __c,
                          const _RWrwstd::__rw_select < true > *) {
        
        return replace (0, size (), __n, __c);
    }


    basic_string<charT, traits, Allocator>& assign (int n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (unsigned int n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (long n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (unsigned long n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (short n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (unsigned short n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (char n, charT c)
    { return replace(0,length(),n,c); }
    basic_string<charT, traits, Allocator>& assign (unsigned char n, charT c)
    { return replace(0,length(),n,c); }

    basic_string<charT, traits, Allocator>& assign (wchar_t n, charT c)
    { return replace(0,length(),n,c); }


    basic_string<charT, traits, Allocator>& assign (bool n, charT c)
    { return replace(0,length(),n,c); }
#line 532 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
  
    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 = _RWreplace_aux(pos-begin(), 0, basic_string<charT, traits, Allocator>(1,c)); 
      _RWpref()->_RWsetRefCount(0);
      return tmp;
    }


    template<class InputIterator>
    inline void insert (iterator, InputIterator, InputIterator);


    template <class _InputIterator>
    void insert (iterator __p, _InputIterator __first, _InputIterator __last,
                 const _RWrwstd::__rw_select < false > *) {
        
        
        replace (__p, __p, __first, __last);
    }

    void insert (iterator __p, size_type __n, value_type __c,
                 const _RWrwstd::__rw_select < true > *) {
        
        replace (__p - begin(), 0, __n, __c);
    }

    void insert (iterator p, int n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, unsigned int n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, long n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, unsigned long n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, short n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, unsigned short n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, char n, charT c)
    { replace(p-begin(),0,n,c); }
    void insert (iterator p, unsigned char n, charT c)
    { replace(p-begin(),0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,int n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned int n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,long n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned long n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,short n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned short n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,char n,charT c)
    { return replace(pos,0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned char n,charT c)
    { return replace(pos,0,n,c); }

    void insert (iterator p, wchar_t n, charT c)
    { replace(p-begin(),0,n,c); }
    basic_string<charT, traits, Allocator>& insert (size_type pos,wchar_t n,charT c)
    { return replace(pos,0,n,c); }


    void insert (iterator p, bool n, charT c)
    { replace(p-begin(),0,n,c);} 
    basic_string<charT, traits, Allocator>& insert (size_type pos,bool n,charT c)
    { return replace(pos,0,n,c); }







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

    iterator erase (iterator it) 
    { 

      iterator ret = replace(it - begin(),1,(charT *) 0L,0,0,0);



      _RWpref()->_RWsetRefCount(0);
      return ret;
    }
    iterator erase (iterator first, iterator last) 
    {  

      iterator ret =  replace(first - begin(),last-first,(charT *)0L,0,0,0);



      _RWpref()->_RWsetRefCount(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 _RWreplace_aux (
        size_type, 
        size_type,
        const basic_string<charT, traits, Allocator>&,
        size_type =0,
        size_type =npos);


    template<class InputIterator>
    basic_string<charT, traits, Allocator>& _RWreplace_aux (
        iterator first1, 
        iterator last1,
        InputIterator first2,
        InputIterator last2);


  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*);


    template<class InputIterator>
    basic_string<charT, traits, Allocator>& replace (iterator, iterator, 
                                                     InputIterator,
                                                     InputIterator);


    template<class _InputIterator>
    basic_string& replace (iterator, iterator,
                           _InputIterator, _InputIterator,
                           const _RWrwstd::__rw_select < false > *);


    basic_string& replace (iterator __first, iterator __last,
                           size_type __n, value_type __c,
                           const _RWrwstd::__rw_select < true > *) {
        
        return replace (__first - begin (), __last - __first, __n, __c);
    }

    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     int n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     unsigned int n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     long n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     unsigned long n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     short n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     unsigned short n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     char n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     unsigned char n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }

    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     wchar_t n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }


    basic_string<charT, traits, Allocator>& replace (iterator first,
                                                     iterator last,
                                                     bool n,
                                                     charT c)
    { return replace(first-begin(),last-first,n,c); }
#line 790 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

    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 = _RWdata_.data(); _RWdata_ = s._RWdata_.data(); s._RWdata_ = temp;
    }

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

    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 _RWgetCapac () const { return _RWpref()->_RWgetCapac(); }

    void _RWclobber (size_type); 
    void _RWcow ()               
    { 
      if (_RWpref()->_RWreferences() > 1) 
        _RWclone(); 
    }
    void _RWcow (size_type nc)     
    { 
      if (_RWpref()->_RWreferences() > 1 || _RWgetCapac() < nc)
        _RWclone(nc);
    }

  private:


    void _RWinitn(size_type, charT);




    static charT _RWeos () { return (charT)0; }
  
    
    
    
    void _RWclone (); 
    
    
    
    void _RWclone (size_type nc);

    _RWstring_ref_type *  _RWpref () const
    { 



      return static_cast< _RWstring_ref_type* >(((reinterpret_cast< _RWstring_ref_type* >(_RWdata_ . data())) - 1)); 


    }

    
    
    
    inline void      _RWunLink          ();   


    friend class _RWrwstd::_RWstring_ref<charT,traits,Allocator>;




    
    
    

    static const _RWnull_ref_type _RWnullref;


    static _RWstring_ref_type * _RWgetNullRep ()
    {




      return reinterpret_cast<_RWstring_ref_type *>
             (const_cast<_RWnull_ref_type *>(&_RWnullref));
#line 937 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
    }
    _RWstring_ref_type * _RWgetRep (size_type capac, size_type nchar);

    _RWrwstd::_RWrw_basis<charT*,allocator_type>    _RWdata_;                   
  };





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


  typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >
  wstring;










}


#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"




















































 



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"


















































 

#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 59 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"







#      pragma __environment __save
#      pragma __environment __cxx_header_defaults









namespace std {









  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();
  };


} 








#      pragma __environment __restore













#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 971 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"






#line 998 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"


namespace std {






  template <class charT, class traits , class Allocator  >
  inline void basic_string<charT, traits, Allocator>::_RWunLink()
  {
    if (!_RWdata_.data())
      return;
    if (_RWpref()->_RWreferences() == 0 || _RWpref()->_RWremoveReference() == 0) 
    {
      _RWref_alloc_type(_RWdata_).destroy(_RWpref());
      _RWvalue_alloc_type(_RWdata_).

        deallocate(reinterpret_cast< typename Allocator::pointer >(_RWpref()),length());



      _RWdata_ = (charT*)0;
    }
  }

  template <class charT, class traits , class Allocator  >
  inline basic_string<charT, traits, Allocator>
  ::basic_string (const Allocator& alloc) : _RWdata_((charT*)0,alloc)
  {
    _RWdata_ = _RWgetNullRep()->data();
    _RWgetNullRep()->_RWaddReference();
  }

#line 1042 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

  template <class charT, class traits , class Allocator  >
  inline
  basic_string<charT, traits, Allocator>
  ::basic_string (const basic_string<charT, traits, Allocator> & s)
   : _RWdata_((charT*)0,Allocator())
  {                     
    if ( s._RWpref()->_RWreferences() > 0 )
    {                                    
      _RWdata_ = s._RWdata_.data();
      _RWpref()->_RWaddReference();
    }
    else
    {
      size_type n = s.length();
      _RWdata_  = _RWgetRep(n, n)->data();
      traits::copy(_RWdata_.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;
  }



  template<class charT, class traits , class Allocator >
  template<class InputIterator>
  inline basic_string<charT, traits, Allocator>& 
  basic_string<charT, traits, Allocator>::append (InputIterator first, 
                                                  InputIterator last )
  {

    return append (first, last, ((_RWrwstd::__rw_select<numeric_limits< InputIterator > ::is_integer> *)0));



    return *this;
  }
#line 1141 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

  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;
  }


  template<class charT, class traits , class Allocator >
  template<class InputIterator>
  inline basic_string<charT, traits, Allocator>& 
  basic_string<charT, traits, Allocator>::assign (InputIterator first, 
                                                  InputIterator last)
  {

    
    
    
    return assign (first, last, ((_RWrwstd::__rw_select<numeric_limits< InputIterator > ::is_integer> *)0));



    return *this;
  }
#line 1199 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

  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;
  }


  template<class charT, class traits , class Allocator >
  template<class InputIterator>
  inline void 
  basic_string<charT, traits, Allocator>::insert (
      iterator p, 
      InputIterator first,
      InputIterator last)
  {

    
    
    
    
    insert (p, first, last, ((_RWrwstd::__rw_select<numeric_limits< InputIterator > ::is_integer> *)0));



  }
#line 1268 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

  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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_StringIndexOutOfRange, "basic_string::erase(size_t,size_t)", 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>::_RWreplace_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;
  }


#line 1398 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"

  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
  {
#line 1409 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
    return reinterpret_cast<reference> (_RWdata_.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)
  {





    _RWcow();
    _RWpref()->_RWsetRefCount(0);

    return reinterpret_cast<reference> (_RWdata_.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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_PosBeyondEndOfString, "basic_string::at(size_t) const", pos,size()). msgstr());




    return reinterpret_cast<reference> (_RWdata_.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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_PosBeyondEndOfString, "basic_string::at(size_t)", pos,size()). msgstr());



    _RWcow();
    _RWpref()->_RWsetRefCount(0);

    return reinterpret_cast<reference> (_RWdata_.data()[pos]);



  }

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

  template <class charT, class traits , class Allocator  >
  inline const charT* basic_string<charT, traits, Allocator>::data () const
  {
    return _RWdata_.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 _RWpref()->_RWnchars_;
  }

  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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_InvalidSizeParam, "basic_string( const charT*,size_type,const Allocator&)",n,npos). msgstr());


    if (n < length())
      erase(n,length()-n);
    else

     replace(length(),0,n-length(),c);



    _RWpref()->_RWsetRefCount(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 _RWgetCapac();
  }

  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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_InvalidSizeParam, "basic_string::reserve(size_t)",res_arg,max_size()). msgstr());



    if (res_arg > _RWgetCapac()) _RWclone(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._RWclone();   
    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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_UnexpectedNullPtr, "basic_string::find(const char*,size_t) const"). msgstr());



    if (pos > length())
      return npos;
    const charT* p = _RWrwstd::rw_traits<charT,traits>::find(_RWdata_.data()+pos,s);
    return p ? p - _RWdata_.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(_RWdata_.data()+pos,length()-pos,c);
    return p ? p - _RWdata_.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 = _RWrwstd::rw_traits<charT,traits>::rfind(_RWdata_.data(),c,pos);
    return p ? p - _RWdata_.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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_UnexpectedNullPtr, "basic_string::find_first_of(char*,size_t) const"). msgstr());



    if (pos > length())
      return npos;
    size_type i = _RWrwstd::rw_traits<charT,traits>::find_first_of(_RWdata_.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(_RWrwstd::except_msg_string(_RWrwstd::_RWrwse_UnexpectedNullPtr, "basic_string::find_first_not_of(char*,size_t) const"). msgstr());



    if (pos > length())
      return npos;
    size_type i = _RWrwstd::rw_traits<charT,traits>::find_first_not_of(_RWdata_.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
  {

    return find_first_not_of(&c, pos, 1);
#line 1685 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"
  }

  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));
  }

  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));
  }

  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);
  }


#line 1966 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/string"






}





#pragma do_not_instantiate const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::size_type std::basic_string<char, std::char_traits<char>, std::allocator<char> >::npos
#pragma do_not_instantiate const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::size_type std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<char> >::npos 

#pragma do_not_instantiate std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const char *, const std::allocator<char> &)
#pragma do_not_instantiate std::basic_string<char, std::char_traits<char>, std::allocator<char> > &std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(const std::basic_string<char, std::char_traits<char>, std::allocator<char> > &)
#pragma do_not_instantiate std::basic_string<char, std::char_traits<char>, std::allocator<char> > &std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(const char *)
#pragma do_not_instantiate char * std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(size_t, size_t, const char *, size_t, size_t, size_t)
#pragma do_not_instantiate _RWrwstd::_RWstring_ref<char, std::char_traits<char>, std::allocator<char> > *std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_RWgetRep(size_t, size_t)
#pragma do_not_instantiate const _RWrwstd::_RWnull_string_ref_rep<char,std::char_traits<char >, std::allocator<char >,_RWrwstd::_RWstring_ref_rep<std::allocator<char > > > std::basic_string<char, std::char_traits<char >, std::allocator<char> >::_RWnullref

#pragma do_not_instantiate const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >::size_type std::basic_string<wchar_t,std::char_traits<wchar_t >, std::allocator<wchar_t > >::npos 

#pragma do_not_instantiate const _RWrwstd::_RWnull_string_ref_rep<wchar_t,std::char_traits<wchar_t >, std::allocator<wchar_t >,_RWrwstd::_RWstring_ref_rep<std::allocator<wchar_t > > > std::basic_string<wchar_t, std::char_traits<wchar_t >,std::allocator<wchar_t > >::_RWnullref













#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 59 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"


#line 220 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/stdexcept"







#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 20 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/arithmetic_traits.hpp"














#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_arithmetic.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_integral.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/is_integral.hpp"

namespace boost {




template< typename T > struct is_integral : mpl::bool_c< false > {   }; 

template< > struct is_integral< unsigned char > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned char const > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned char volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned char const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< unsigned short > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned short const > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned short volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned short const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< unsigned int > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned int const > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned int volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned int const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< unsigned long > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned long const > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned long volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned long const volatile > : mpl::bool_c< true > {   };

template< > struct is_integral< signed char > : mpl::bool_c< true > {   }; template< > struct is_integral< signed char const > : mpl::bool_c< true > {   }; template< > struct is_integral< signed char volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< signed char const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< signed short > : mpl::bool_c< true > {   }; template< > struct is_integral< signed short const > : mpl::bool_c< true > {   }; template< > struct is_integral< signed short volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< signed short const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< signed int > : mpl::bool_c< true > {   }; template< > struct is_integral< signed int const > : mpl::bool_c< true > {   }; template< > struct is_integral< signed int volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< signed int const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< signed long > : mpl::bool_c< true > {   }; template< > struct is_integral< signed long const > : mpl::bool_c< true > {   }; template< > struct is_integral< signed long volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< signed long const volatile > : mpl::bool_c< true > {   };

template< > struct is_integral< bool > : mpl::bool_c< true > {   }; template< > struct is_integral< bool const > : mpl::bool_c< true > {   }; template< > struct is_integral< bool volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< bool const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< char > : mpl::bool_c< true > {   }; template< > struct is_integral< char const > : mpl::bool_c< true > {   }; template< > struct is_integral< char volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< char const volatile > : mpl::bool_c< true > {   };


template< > struct is_integral< wchar_t > : mpl::bool_c< true > {   }; template< > struct is_integral< wchar_t const > : mpl::bool_c< true > {   }; template< > struct is_integral< wchar_t volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< wchar_t const volatile > : mpl::bool_c< true > {   };


#line 50 "/net/cci/rwgk/dist/boost/boost/type_traits/is_integral.hpp"


template< > struct is_integral< unsigned long long > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned long long const > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned long long volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< unsigned long long const volatile > : mpl::bool_c< true > {   };
template< > struct is_integral< long long > : mpl::bool_c< true > {   }; template< > struct is_integral< long long const > : mpl::bool_c< true > {   }; template< > struct is_integral< long long volatile > : mpl::bool_c< true > {   }; template< > struct is_integral< long long const volatile > : mpl::bool_c< true > {   };





} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 62 "/net/cci/rwgk/dist/boost/boost/type_traits/is_integral.hpp"

#line 14 "/net/cci/rwgk/dist/boost/boost/type_traits/is_arithmetic.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_float.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/is_float.hpp"

namespace boost {


template< typename T > struct is_float : mpl::bool_c< false > {   }; 
template< > struct is_float< float > : mpl::bool_c< true > {   }; template< > struct is_float< float const > : mpl::bool_c< true > {   }; template< > struct is_float< float volatile > : mpl::bool_c< true > {   }; template< > struct is_float< float const volatile > : mpl::bool_c< true > {   };
template< > struct is_float< double > : mpl::bool_c< true > {   }; template< > struct is_float< double const > : mpl::bool_c< true > {   }; template< > struct is_float< double volatile > : mpl::bool_c< true > {   }; template< > struct is_float< double const volatile > : mpl::bool_c< true > {   };
template< > struct is_float< long double > : mpl::bool_c< true > {   }; template< > struct is_float< long double const > : mpl::bool_c< true > {   }; template< > struct is_float< long double volatile > : mpl::bool_c< true > {   }; template< > struct is_float< long double const volatile > : mpl::bool_c< true > {   };

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 27 "/net/cci/rwgk/dist/boost/boost/type_traits/is_float.hpp"

#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/is_arithmetic.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/ice_or.hpp"














namespace boost {
namespace type_traits {

template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;

template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
    static const bool value = true;
};

template <>
struct ice_or<false, false, false, false, false, false, false>
{
    static const bool value = false;
};

} 
} 

#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/is_arithmetic.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/is_arithmetic.hpp"

namespace boost {

namespace detail {

template< typename T >
struct is_arithmetic_impl
{ 
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T> ::value, ::boost::is_float<T> ::value > ::value); 




};

} 


template< typename T > struct is_arithmetic : mpl::bool_c< ::boost::detail::is_arithmetic_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 43 "/net/cci/rwgk/dist/boost/boost/type_traits/is_arithmetic.hpp"

#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/arithmetic_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_fundamental.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_void.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/is_void.hpp"

namespace boost {


template< typename T > struct is_void : mpl::bool_c< false > {   }; 
template< > struct is_void< void > : mpl::bool_c< true > {   };


template< > struct is_void< void const > : mpl::bool_c< true > {   };
template< > struct is_void< void volatile > : mpl::bool_c< true > {   };
template< > struct is_void< void const volatile > : mpl::bool_c< true > {   };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 33 "/net/cci/rwgk/dist/boost/boost/type_traits/is_void.hpp"

#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/is_fundamental.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 19 "/net/cci/rwgk/dist/boost/boost/type_traits/is_fundamental.hpp"

namespace boost {

namespace detail {

template <typename T> 
struct is_fundamental_impl
    : ::boost::type_traits::ice_or< 
          ::boost::is_arithmetic<T>::value
        , ::boost::is_void<T>::value
        >
{ 
};

} 


template< typename T > struct is_fundamental : mpl::bool_c< ::boost::detail::is_fundamental_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 41 "/net/cci/rwgk/dist/boost/boost/type_traits/is_fundamental.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/arithmetic_traits.hpp"



#line 25 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/composite_traits.hpp"
























#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_array.hpp"























#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 25 "/net/cci/rwgk/dist/boost/boost/type_traits/is_array.hpp"

namespace boost {



template< typename T > struct is_array : mpl::bool_c< false > {   }; 
template< typename T, std::size_t N > struct is_array< T[N] > : mpl::bool_c< true > {  };
template< typename T, std::size_t N > struct is_array< T const[N] > : mpl::bool_c< true > {  };
template< typename T, std::size_t N > struct is_array< T volatile[N] > : mpl::bool_c< true > {  };
template< typename T, std::size_t N > struct is_array< T const volatile[N] > : mpl::bool_c< true > {  };

#line 73 "/net/cci/rwgk/dist/boost/boost/type_traits/is_array.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/is_array.hpp"

#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/composite_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/add_reference.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_reference.hpp"


























#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 28 "/net/cci/rwgk/dist/boost/boost/type_traits/is_reference.hpp"

namespace boost { 



template< typename T > struct is_reference : mpl::bool_c< false > {   }; 
template< typename T > struct is_reference< T& > : mpl::bool_c< true > {  };

#line 45 "/net/cci/rwgk/dist/boost/boost/type_traits/is_reference.hpp"

#line 59 "/net/cci/rwgk/dist/boost/boost/type_traits/is_reference.hpp"

#line 104 "/net/cci/rwgk/dist/boost/boost/type_traits/is_reference.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 108 "/net/cci/rwgk/dist/boost/boost/type_traits/is_reference.hpp"



#line 14 "/net/cci/rwgk/dist/boost/boost/type_traits/add_reference.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"


#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 46 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_def.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/add_reference.hpp"

namespace boost {



template< typename T > struct add_reference { typedef T& type;  }; 
template< typename T > struct add_reference<T& > { typedef T& type; };

#line 67 "/net/cci/rwgk/dist/boost/boost/type_traits/add_reference.hpp"



template< > struct add_reference<void> { typedef void type;  };

template< > struct add_reference<void const> { typedef void const type;  };
template< > struct add_reference<void volatile> { typedef void volatile type;  };
template< > struct add_reference<void const volatile> { typedef void const volatile type;  };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/type_trait_undef.hpp"


















#line 80 "/net/cci/rwgk/dist/boost/boost/type_traits/add_reference.hpp"

#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/yes_no_type.hpp"














namespace boost {
namespace type_traits {

typedef char yes_type;
struct no_type
{
   char padding[8];
};

} 
} 

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"







#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 28 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"

namespace boost {











namespace detail {



#line 130 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"






struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    
    
    template <typename T> any_conversion(T&);
};

template <typename From, typename To>
struct is_convertible_impl
{
    static ::boost::type_traits::no_type  _m_check(any_conversion ...);
    static ::boost::type_traits::yes_type  _m_check(To, int);
    static From _m_from;

    static const bool value = sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type);


};

#line 175 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"

} 

template< typename From, typename To > struct is_convertible : mpl::bool_c< (::boost::detail::is_convertible_impl<From,To> ::value) > {   }; 







template< typename To > struct is_convertible< void,To > : mpl::bool_c< false > {   };
template< typename From > struct is_convertible< From,void > : mpl::bool_c< false > {   };

template< typename To > struct is_convertible< void const,To > : mpl::bool_c< false > {   };
template< typename To > struct is_convertible< void volatile,To > : mpl::bool_c< false > {   };
template< typename To > struct is_convertible< void const volatile,To > : mpl::bool_c< false > {   };
template< typename From > struct is_convertible< From,void const > : mpl::bool_c< false > {   };
template< typename From > struct is_convertible< From,void volatile > : mpl::bool_c< false > {   };
template< typename From > struct is_convertible< From,void const volatile > : mpl::bool_c< false > {   };



#line 205 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"

#line 212 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"

    template< > struct is_convertible< void,void > : mpl::bool_c< true > {   }; template< > struct is_convertible< void,void const > : mpl::bool_c< true > {   }; template< > struct is_convertible< void,void volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void,void const volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const,void > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const,void const > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const,void volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const,void const volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void volatile,void > : mpl::bool_c< true > {   }; template< > struct is_convertible< void volatile,void const > : mpl::bool_c< true > {   }; template< > struct is_convertible< void volatile,void volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void volatile,void const volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const volatile,void > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const volatile,void const > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const volatile,void volatile > : mpl::bool_c< true > {   }; template< > struct is_convertible< void const volatile,void const volatile > : mpl::bool_c< true > {   };









#line 263 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 267 "/net/cci/rwgk/dist/boost/boost/type_traits/is_convertible.hpp"



#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"







#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"

namespace boost {



namespace detail {
  
struct int_convertible
{
    int_convertible(int);
};



template <bool is_typename_arithmetic_or_reference = true>
struct is_enum_helper
{
    template <typename T> struct type
    {
        static const bool value = false;
    };
};

template <>
struct is_enum_helper<false>
{
    template <typename T> struct type
        : ::boost::is_convertible<T,::boost::detail::int_convertible>
    {
    };
};

template <typename T> struct is_enum_impl
{
   typedef ::boost::add_reference<T> ar_t;
   typedef typename ar_t::type r_type;
       
#line 74 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"
   static const bool selector = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T> ::value , ::boost::is_reference<T> ::value > ::value);
#line 82 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"






    typedef ::boost::detail::is_enum_helper<selector> se_t;

    typedef typename se_t::template type<r_type> helper;
    static const bool value = helper::value;
};

} 

template< typename T > struct is_enum : mpl::bool_c< ::boost::detail::is_enum_impl<T> ::value > {   }; 


template< > struct is_enum< float > : mpl::bool_c< false > {   };
template< > struct is_enum< double > : mpl::bool_c< false > {   };
template< > struct is_enum< long double > : mpl::bool_c< false > {   };

template< > struct is_enum< void > : mpl::bool_c< false > {   };

template< > struct is_enum< void const > : mpl::bool_c< false > {   };
template< > struct is_enum< void volatile > : mpl::bool_c< false > {   };
template< > struct is_enum< void const volatile > : mpl::bool_c< false > {   };


#line 117 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 121 "/net/cci/rwgk/dist/boost/boost/type_traits/is_enum.hpp"

#line 27 "/net/cci/rwgk/dist/boost/boost/type_traits/composite_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_pointer.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_function_pointer.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"























namespace boost {
namespace type_traits {

template <typename T>
struct is_mem_fun_pointer_impl
{
    static const bool value = false;
};




template <class R,class T>
struct is_mem_fun_pointer_impl<R (T::*)()> { static const bool value = true; };

template <class R,class T>
struct is_mem_fun_pointer_impl<R (T::*)() const> { static const bool value = true; };
template <class R,class T>
struct is_mem_fun_pointer_impl<R (T::*)() volatile> { static const bool value = true; };
template <class R,class T>
struct is_mem_fun_pointer_impl<R (T::*)() const volatile> { static const bool value = true; };


template <class R,class T,class T0>
struct is_mem_fun_pointer_impl<R (T::*)(T0)> { static const bool value = true; };

template <class R,class T,class T0>
struct is_mem_fun_pointer_impl<R (T::*)(T0) const> { static const bool value = true; };
template <class R,class T,class T0>
struct is_mem_fun_pointer_impl<R (T::*)(T0) volatile> { static const bool value = true; };
template <class R,class T,class T0>
struct is_mem_fun_pointer_impl<R (T::*)(T0) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1)> { static const bool value = true; };

template <class R,class T,class T0,class T1>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) const> { static const bool value = true; };
template <class R,class T,class T0,class T1>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const volatile> { static const bool value = true; };


template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)> { static const bool value = true; };

template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) volatile> { static const bool value = true; };
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const volatile> { static const bool value = true; };


#line 330 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"

} 
} 





#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_function_pointer.hpp"
#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_function_pointer.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 29 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_function_pointer.hpp"

namespace boost {







template< typename T > struct is_member_function_pointer : mpl::bool_c< ::boost::type_traits::is_mem_fun_pointer_impl<T> ::value > {   }; 

#line 112 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_function_pointer.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 116 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_function_pointer.hpp"

#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_pointer.hpp"
#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_pointer.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 29 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_pointer.hpp"

namespace boost {






template< typename T > struct is_member_pointer : mpl::bool_c< ::boost::is_member_function_pointer<T> ::value > {   }; 
template< typename T, typename U > struct is_member_pointer< U T:: * > : mpl::bool_c< true > {  };

#line 91 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_pointer.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 95 "/net/cci/rwgk/dist/boost/boost/type_traits/is_member_pointer.hpp"

#line 28 "/net/cci/rwgk/dist/boost/boost/type_traits/composite_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/ice_and.hpp"














namespace boost {
namespace type_traits {

template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;

template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
    static const bool value = false;
};

template <>
struct ice_and<true, true, true, true, true, true, true>
{
    static const bool value = true;
};

} 
} 

#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/ice_not.hpp"














namespace boost {
namespace type_traits {

template <bool b>
struct ice_not
{
    static const bool value = true;
};

template <>
struct ice_not<true>
{
    static const bool value = false;
};

} 
} 

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"


#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 29 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"

namespace boost {



namespace detail {

template< typename T > struct is_pointer_helper
{
    static const bool value = false;
};

#line 47 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"

template< typename T > struct is_pointer_helper<T* > { static const bool value = true; };
template< typename T > struct is_pointer_helper<T* const> { static const bool value = true; };
template< typename T > struct is_pointer_helper<T* volatile> { static const bool value = true; };
template< typename T > struct is_pointer_helper<T* const volatile> { static const bool value = true; };



template< typename T >
struct is_pointer_impl
{
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<T> ::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T> ::value > ::value > ::value);
#line 66 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"
};

} 

template< typename T > struct is_pointer : mpl::bool_c< ::boost::detail::is_pointer_impl<T> ::value > {   }; 
#line 81 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"

#line 137 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 141 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pointer.hpp"

#line 30 "/net/cci/rwgk/dist/boost/boost/type_traits/composite_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_union.hpp"













#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/intrinsics.hpp"































#line 43 "/net/cci/rwgk/dist/boost/boost/type_traits/intrinsics.hpp"

#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/intrinsics.hpp"


































#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/is_union.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/is_union.hpp"

namespace boost {

namespace detail {
template <typename T> struct is_union_impl
{
   typedef typename remove_cv<T>::type cvt;
   static const bool value = false;
};
} 

template< typename T > struct is_union : mpl::bool_c< ::boost::detail::is_union_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 36 "/net/cci/rwgk/dist/boost/boost/type_traits/is_union.hpp"

#line 32 "/net/cci/rwgk/dist/boost/boost/type_traits/composite_traits.hpp"







#line 26 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_constructor.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pod.hpp"












#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_scalar.hpp"












#line 19 "/net/cci/rwgk/dist/boost/boost/type_traits/is_scalar.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/is_scalar.hpp"

namespace boost {

namespace detail {

template <typename T>
struct is_scalar_impl
{ 
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T> ::value, ::boost::is_enum<T> ::value, ::boost::is_pointer<T> ::value, ::boost::is_member_pointer<T> ::value > ::value);
#line 37 "/net/cci/rwgk/dist/boost/boost/type_traits/is_scalar.hpp"
};



template <> struct is_scalar_impl<void>{ static const bool value = false; };

template <> struct is_scalar_impl<void const>{ static const bool value = false; };
template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };


} 

template< typename T > struct is_scalar : mpl::bool_c< ::boost::detail::is_scalar_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 55 "/net/cci/rwgk/dist/boost/boost/type_traits/is_scalar.hpp"

#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pod.hpp"






#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pod.hpp"

namespace boost {


template< typename T > struct is_POD;

namespace detail {



template <typename T> struct is_POD_impl
{ 
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T> ::value, ::boost::is_void<T> ::value, false > ::value);
#line 42 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pod.hpp"
};

template <typename T, std::size_t sz>
struct is_POD_impl<T[sz]>
    : is_POD_impl<T>
{
};

#line 115 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pod.hpp"

} 

template< typename T > struct is_POD : mpl::bool_c< ::boost::detail::is_POD_impl<T> ::value > {   }; 


template< > struct is_POD< void > : mpl::bool_c< true > {   };


template< > struct is_POD< void const > : mpl::bool_c< true > {   };
template< > struct is_POD< void volatile > : mpl::bool_c< true > {   };
template< > struct is_POD< void const volatile > : mpl::bool_c< true > {   };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 132 "/net/cci/rwgk/dist/boost/boost/type_traits/is_pod.hpp"

#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_constructor.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_constructor.hpp"

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_ctor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_POD<T> ::value, false > ::value);




};

} 

template< typename T > struct has_trivial_constructor : mpl::bool_c< ::boost::detail::has_trivial_ctor_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 42 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_constructor.hpp"

#line 14 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_copy.hpp"












#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_copy.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_copy.hpp"

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_copy_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_POD<T> ::value, false > ::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T> ::value > ::value > ::value);
#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_copy.hpp"
};

} 

template< typename T > struct has_trivial_copy : mpl::bool_c< ::boost::detail::has_trivial_copy_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 48 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_copy.hpp"

#line 15 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_destructor.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_destructor.hpp"

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_dtor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_POD<T> ::value, false > ::value);




};

} 

template< typename T > struct has_trivial_destructor : mpl::bool_c< ::boost::detail::has_trivial_dtor_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 42 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_destructor.hpp"

#line 16 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_class.hpp"

















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_function.hpp"
















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/false_result.hpp"











namespace boost {
namespace type_traits {


struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};

}} 

#line 19 "/net/cci/rwgk/dist/boost/boost/type_traits/is_function.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/is_function_ptr_helper.hpp"




























namespace boost {
namespace type_traits {

template <class R>
struct is_function_ptr_helper
{
    static const bool value = false;
};




template <class R>
struct is_function_ptr_helper<R (*)()> { static const bool value = true; };

template <class R,class T0>
struct is_function_ptr_helper<R (*)(T0)> { static const bool value = true; };

template <class R,class T0,class T1>
struct is_function_ptr_helper<R (*)(T0,T1)> { static const bool value = true; };

template <class R,class T0,class T1,class T2>
struct is_function_ptr_helper<R (*)(T0,T1,T2)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)> { static const bool value = true; };

template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)> { static const bool value = true; };

#line 127 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/is_function_ptr_helper.hpp"

} 
} 





#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/is_function.hpp"






#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 30 "/net/cci/rwgk/dist/boost/boost/type_traits/is_function.hpp"







namespace boost {
namespace detail {


template<bool is_ref = true>
struct is_function_chooser
    : ::boost::type_traits::false_result
{
};

template <>
struct is_function_chooser<false>
{
    template< typename T > struct result_
        : ::boost::type_traits::is_function_ptr_helper<T*>
    {
    };
};

template <typename T>
struct is_function_impl
    : is_function_chooser< ::boost::is_reference<T>::value >
        ::template result_<T>
{
};

#line 76 "/net/cci/rwgk/dist/boost/boost/type_traits/is_function.hpp"

} 

template< typename T > struct is_function : mpl::bool_c< ::boost::detail::is_function_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 84 "/net/cci/rwgk/dist/boost/boost/type_traits/is_function.hpp"

#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/is_class.hpp"



#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 30 "/net/cci/rwgk/dist/boost/boost/type_traits/is_class.hpp"

namespace boost {

namespace detail {

#line 63 "/net/cci/rwgk/dist/boost/boost/type_traits/is_class.hpp"

template <typename T>
struct is_class_impl
{

    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_union<T> ::value > ::value, ::boost::type_traits::ice_not< ::boost::is_scalar<T> ::value > ::value, ::boost::type_traits::ice_not< ::boost::is_array<T> ::value > ::value, ::boost::type_traits::ice_not< ::boost::is_reference<T> ::value> ::value, ::boost::type_traits::ice_not< ::boost::is_void<T> ::value > ::value, ::boost::type_traits::ice_not< ::boost::is_function<T> ::value > ::value > ::value);
#line 87 "/net/cci/rwgk/dist/boost/boost/type_traits/is_class.hpp"
};



} 

template< typename T > struct is_class : mpl::bool_c< ::boost::detail::is_class_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 98 "/net/cci/rwgk/dist/boost/boost/type_traits/is_class.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"

















#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 34 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"

namespace boost {

namespace detail {


template <typename T>
struct empty_helper_t1 : public T
{
    empty_helper_t1();  
    int i[256];
};

struct empty_helper_t2 { int i[256]; };



template <typename T, bool is_a_class = false>
struct empty_helper
{
    static const bool value = false;
};

template <typename T>
struct empty_helper<T, true>
{
    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2));


};

template <typename T>
struct is_empty_impl
{
    typedef typename remove_cv<T>::type cvt;
    static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T> ::value> ::value , false > ::value );
#line 76 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"
};

#line 113 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"

#line 190 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"

} 

template< typename T > struct is_empty : mpl::bool_c< ::boost::detail::is_empty_impl<T> ::value > {   }; 

template< > struct is_empty< void > : mpl::bool_c< false > {   };

template< > struct is_empty< void const > : mpl::bool_c< false > {   };
template< > struct is_empty< void volatile > : mpl::bool_c< false > {   };
template< > struct is_empty< void const volatile > : mpl::bool_c< false > {   };



} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 206 "/net/cci/rwgk/dist/boost/boost/type_traits/is_empty.hpp"



#line 18 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"




#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"

namespace boost {

namespace detail {

template <typename T>
struct is_stateless_impl
{
  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T> ::value, ::boost::has_trivial_copy<T> ::value, ::boost::has_trivial_destructor<T> ::value, ::boost::is_class<T> ::value, ::boost::is_empty<T> ::value > ::value);
#line 39 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"
};

} 

template< typename T > struct is_stateless : mpl::bool_c< ::boost::detail::is_stateless_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 48 "/net/cci/rwgk/dist/boost/boost/type_traits/is_stateless.hpp"

#line 27 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/ref.hpp"







#line 1 "/net/cci/rwgk/dist/boost/boost/utility/addressof.hpp"


















namespace boost {



template <typename T> T* addressof(T& v)
{
  return reinterpret_cast<T*>(
       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
}

}

#line 10 "/net/cci/rwgk/dist/boost/boost/ref.hpp"
















namespace boost
{

template<class T> class reference_wrapper
{ 
public:
    typedef T type;







    explicit reference_wrapper(T& t): t_(addressof(t)) {}



    operator T& () const { return *t_; }

    T& get() const { return *t_; }

    T* get_pointer() const { return t_; }

private:

    T* t_;
};







template<class T> inline reference_wrapper<T> const ref(T & t)
{ 
    return reference_wrapper<T>(t);
}

template<class T> inline reference_wrapper<T const> const cref(T const & t)
{
    return reference_wrapper<T const>(t);
}




template<typename T>
class is_reference_wrapper
{
 public:
    static const bool value = false; 
};

template<typename T>
class is_reference_wrapper<reference_wrapper<T> >
{
 public:
    static const bool value = true;
};

template<typename T>
class unwrap_reference
{
 public:
    typedef T type;
};

template<typename T>
class unwrap_reference<reference_wrapper<T> >
{
 public:
    typedef T type;
};
#line 159 "/net/cci/rwgk/dist/boost/boost/ref.hpp"

} 

#line 28 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/pending/ct_if.hpp"



















 

namespace boost {

  struct ct_if_error { };

  struct true_type { enum { value = true }; };
  struct false_type { enum { value = false }; };

  template <class A, class B>
  struct ct_and { typedef false_type type; };
  template <> struct ct_and<true_type,true_type> { typedef true_type type; };

  template <class A> struct ct_not { typedef ct_if_error type; };
  template <> struct ct_not<true_type> { typedef false_type type; };
  template <> struct ct_not<false_type> { typedef true_type type; };








  template <bool cond, class A, class B>
  struct ct_if { typedef ct_if_error type; };
  template <class A, class B>
  struct ct_if<true, A, B> { typedef A type; };
  template <class A, class B>
  struct ct_if<false, A, B> { typedef B type; };
#line 56 "/net/cci/rwgk/dist/boost/boost/pending/ct_if.hpp"

  template <class cond, class A, class B>
  struct ct_if_t { typedef ct_if_error type; };
  template <class A, class B>
  struct ct_if_t<true_type, A, B> { typedef A type; };
  template <class A, class B>
  struct ct_if_t<false_type, A, B> { typedef B type; };

#line 108 "/net/cci/rwgk/dist/boost/boost/pending/ct_if.hpp"

} 



#line 29 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"







#line 44 "/net/cci/rwgk/dist/boost/boost/function/function_base.hpp"























namespace boost {

template<typename Signature, typename Allocator = std::allocator<void> >
class function;

template<typename Signature, typename Allocator>
inline void swap(function<Signature, Allocator>& f1,
                 function<Signature, Allocator>& f2)
{
  f1.swap(f2);
}

} 


namespace boost {
  namespace detail {
    namespace function {
      





 
      union any_pointer
      {
        void* obj_ptr;
        const void* const_obj_ptr;
        void (*func_ptr)();
        char data[1];
      };

      inline any_pointer make_any_pointer(void* o)
      {
        any_pointer p;
        p.obj_ptr = o;
        return p;
      }

      inline any_pointer make_any_pointer(const void* o)
      {
        any_pointer p;
        p.const_obj_ptr = o;
        return p;
      }

      inline any_pointer make_any_pointer(void (*f)())
      {
        any_pointer p;
        p.func_ptr = f;
        return p;
      }

      




 
      struct unusable
      {
        unusable() {}
        template<typename T> unusable(const T&) {}
      };

      


 
      template<typename T> struct function_return_type { typedef T type; };

      template<>
      struct function_return_type<void>
      {
        typedef unusable type;
      };

      
      enum functor_manager_operation_type {
        clone_functor_tag,
        destroy_functor_tag
      };

      
      struct function_ptr_tag {};
      struct function_obj_tag {};
      struct member_ptr_tag {};
      struct function_obj_ref_tag {};
      struct stateless_function_obj_tag {};

      template<typename F>
      class get_function_tag
      {
        typedef typename ct_if<(is_pointer<F>::value),
                            function_ptr_tag,
                            function_obj_tag>::type ptr_or_obj_tag;

        typedef typename ct_if<(is_member_pointer<F>::value),
                            member_ptr_tag,
                            ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

        typedef typename ct_if<(is_reference_wrapper<F>::value),
                             function_obj_ref_tag,
                             ptr_or_obj_or_mem_tag>::type or_ref_tag;

      public:
        typedef typename ct_if<(is_stateless<F>::value),
                            stateless_function_obj_tag,
                            or_ref_tag>::type type;
      };

      
      
      inline any_pointer trivial_manager(any_pointer f,
                                         functor_manager_operation_type op)
      {
        if (op == clone_functor_tag)
          return f;
        else
          return make_any_pointer(reinterpret_cast<void*>(0));
      }

      


 
      template<typename Functor, typename Allocator>
      struct functor_manager
      {
      private:
        typedef Functor functor_type;

        
        static inline any_pointer
        manager(any_pointer function_ptr,
                functor_manager_operation_type op,
                function_ptr_tag)
        {
          if (op == clone_functor_tag)
            return function_ptr;
          else
            return make_any_pointer(static_cast<void (*)()>(0));
        }

        
        
        static inline any_pointer
        manager(any_pointer function_obj_ptr,
                functor_manager_operation_type op,
                function_obj_tag)
        {

        typedef typename Allocator::template rebind<functor_type>::other
          allocator_type;
        typedef typename allocator_type::pointer pointer_type;





          allocator_type allocator;


          if (op == clone_functor_tag) {
            functor_type* f =
              static_cast<functor_type*>(function_obj_ptr.obj_ptr);

            

            pointer_type copy = allocator.allocate(1);
            allocator.construct(copy, *f);

            
            functor_type* new_f = static_cast<functor_type*>(copy);



            return make_any_pointer(static_cast<void*>(new_f));
          }
          else {
             
            functor_type* f =
              reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);


            
 
            pointer_type victim = static_cast<pointer_type>(f);

            
            allocator.destroy(victim);
            allocator.deallocate(victim, 1);




            return make_any_pointer(static_cast<void*>(0));
          }
        }
      public:
        
 
        static any_pointer
        manage(any_pointer functor_ptr, functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          return manager(functor_ptr, op, tag_type());
        }
      };

      template<bool>
      struct enabled
      {
        template<typename T>
        struct base
        {
          typedef T type;
        };
      };

      template<>
      struct enabled<false>
      {
        template<typename T>
        struct base
        {
        };
      };

      template<bool Enabled, typename T>
      struct enable_if : public enabled<Enabled>::template base<T>
      {
      };
    } 
  } 






 
class function_base
{
public:
  function_base() : manager(0)
  {
    functor.obj_ptr = 0;
  }

  
  bool empty() const { return !manager; }

public: 
  detail::function::any_pointer (*manager)(
    detail::function::any_pointer,
    detail::function::functor_manager_operation_type);
  detail::function::any_pointer functor;
};




 
class bad_function_call : public std::runtime_error
{
public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
};






 
void operator==(const function_base&, const function_base&);
void operator!=(const function_base&, const function_base&);

namespace detail {
  namespace function {
    inline bool has_empty_target(const function_base* f)
    {
      return f->empty();
    }

    inline bool has_empty_target(...)
    {
      return false;
    }
  } 
} 
} 

#line 8 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"























namespace boost
{



template<class T> T * get_pointer(T * p)
{
    return p;
}



#line 170 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"




namespace _mfi
{






#line 1 "/net/cci/rwgk/dist/boost/boost/bind/mem_fn_template.hpp"

















template<class R, class T > class mf0
{
public:

    typedef R result_type;
    typedef T * argument_type;

private:
    
    typedef R ( T:: *F) ();
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:
    
    explicit mf0(F f): f_(f) {}

    R operator()(T * p) const
    {
        return (p->*f_)();
    }

    template<class U> R operator()(U & u) const
    {
        return call(u, &u);
    }

    R operator()(T & t) const
    {
        return (t.*f_)();
    }
};



template<class R, class T > class cmf0
{
public:

    typedef R result_type;
    typedef T const * argument_type;

private:
    
    typedef R ( T:: *F) () const;
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:
    
    explicit cmf0(F f): f_(f) {}

    template<class U> R operator()(U const & u) const
    {
        return call(u, &u);
    }

    R operator()(T const & t) const
    {
        return (t.*f_)();
    }
};



template<class R, class T, class A1 > class mf1
{
public:

    typedef R result_type;
    typedef T * first_argument_type;
    typedef A1 second_argument_type;

private:
    
    typedef R ( T:: *F) (A1);
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
        return (get_pointer(u)->*f_)(b1);
    }

public:
    
    explicit mf1(F f): f_(f) {}

    R operator()(T * p, A1 a1) const
    {
        return (p->*f_)(a1);
    }

    template<class U> R operator()(U & u, A1 a1) const
    {
        return call(u, &u, a1);
    }

    R operator()(T & t, A1 a1) const
    {
        return (t.*f_)(a1);
    }
};



template<class R, class T, class A1 > class cmf1
{
public:

    typedef R result_type;
    typedef T const * first_argument_type;
    typedef A1 second_argument_type;

private:
    
    typedef R ( T:: *F) (A1) const;
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
        return (get_pointer(u)->*f_)(b1);
    }

public:
    
    explicit cmf1(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1) const
    {
        return call(u, &u, a1);
    }

    R operator()(T const & t, A1 a1) const
    {
        return (t.*f_)(a1);
    }
};



template<class R, class T, class A1, class A2 > class mf2
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2);
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
        return (get_pointer(u)->*f_)(b1, b2);
    }

public:
    
    explicit mf2(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2) const
    {
        return (p->*f_)(a1, a2);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2) const
    {
        return call(u, &u, a1, a2);
    }

    R operator()(T & t, A1 a1, A2 a2) const
    {
        return (t.*f_)(a1, a2);
    }
};



template<class R, class T, class A1, class A2 > class cmf2
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2) const;
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
        return (get_pointer(u)->*f_)(b1, b2);
    }

public:
    
    explicit cmf2(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        return call(u, &u, a1, a2);
    }

    R operator()(T const & t, A1 a1, A2 a2) const
    {
        return (t.*f_)(a1, a2);
    }
};



template<class R, class T, class A1, class A2, class A3 > class mf3
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3);
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

public:
    
    explicit mf3(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
    {
        return (p->*f_)(a1, a2, a3);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
    {
        return call(u, &u, a1, a2, a3);
    }

    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
    {
        return (t.*f_)(a1, a2, a3);
    }
};



template<class R, class T, class A1, class A2, class A3 > class cmf3
{
public:

    typedef R result_type;

private:

    typedef R ( T:: *F) (A1, A2, A3) const;
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

public:

    explicit cmf3(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        return call(u, &u, a1, a2, a3);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
    {
        return (t.*f_)(a1, a2, a3);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4);
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

public:
    
    explicit mf4(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (p->*f_)(a1, a2, a3, a4);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return call(u, &u, a1, a2, a3, a4);
    }

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (t.*f_)(a1, a2, a3, a4);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

public:
    
    explicit cmf4(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return call(u, &u, a1, a2, a3, a4);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (t.*f_)(a1, a2, a3, a4);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

public:
    
    explicit mf5(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return call(u, &u, a1, a2, a3, a4, a5);
    }

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

public:
    
    explicit cmf5(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return call(u, &u, a1, a2, a3, a4, a5);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
{
public:

    typedef R result_type;

private:

    typedef R ( T:: *F) (A1, A2, A3, A4, A5, A6);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

public:

    explicit mf6(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6);
    }

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5, A6) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

public:
    
    explicit cmf6(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5, A6, A7);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

public:
    
    explicit mf7(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6, a7);
    }

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5, A6, A7) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

public:
    
    explicit cmf7(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6, a7);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5, A6, A7, A8);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

public:
    
    explicit mf8(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
{
public:

    typedef R result_type;

private:
    
    typedef R ( T:: *F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

public:
    
    explicit cmf8(F f): f_(f) {}

    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }
};

#line 183 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"




#line 198 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"

#line 210 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"



} 









#line 1 "/net/cci/rwgk/dist/boost/boost/bind/mem_fn_cc.hpp"















template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
{
    return _mfi::mf0<R, T>(f);
}

template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
{
    return _mfi::cmf0<R, T>(f);
}

template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
{
    return _mfi::mf1<R, T, A1>(f);
}

template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
{
    return _mfi::cmf1<R, T, A1>(f);
}

template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
{
    return _mfi::mf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
{
    return _mfi::cmf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
{
    return _mfi::mf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
{
    return _mfi::cmf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
{
    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
{
    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
{
    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
{
    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
{
    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
{
    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
{
    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
{
    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
{
    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
#line 224 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"




#line 239 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"

#line 251 "/net/cci/rwgk/dist/boost/boost/mem_fn.hpp"



namespace _mfi
{

template<class R, class T> class dm
{
public:

    typedef R const & result_type;
    typedef T const * argument_type;

private:
    
    typedef R (T::*F);
    F f_;

    template<class U> R const & call(U & u, T const *) const
    {
        return (u.*f_);
    }

    template<class U> R & call(U & u, T *) const
    {
        return (u.*f_);
    }

    template<class U> R const & call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_);
    }

public:
    
    explicit dm(F f): f_(f) {}

    R & operator()(T * p) const
    {
        return (p->*f_);
    }

    R const & operator()(T const * p) const
    {
        return (p->*f_);
    }

    template<class U> R const & operator()(U & u) const
    {
        return call(u, &u);
    }



    R & operator()(T & t) const
    {
        return (t.*f_);
    }



    R const & operator()(T const & t) const
    {
        return (t.*f_);
    }
};

} 

template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
{
    return _mfi::dm<R, T>(f);
}

} 

#line 9 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 20 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/debug/error.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/debug/error.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 18 "/net/cci/rwgk/dist/boost/boost/preprocessor/debug/error.hpp"
#line 21 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/detail/auto_rec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/iif.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/iif.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/detail/auto_rec.hpp"
#line 22 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma_if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma_if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/iif.hpp"
#line 20 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/logical/bool.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/logical/bool.hpp"
#line 21 "/net/cci/rwgk/dist/boost/boost/preprocessor/control/if.hpp"
#line 20 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma_if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/facilities/empty.hpp"
#line 21 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma_if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma.hpp"
#line 22 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma_if.hpp"
#line 23 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 20 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/debug/error.hpp"
#line 21 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/detail/auto_rec.hpp"
#line 22 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/tuple/eat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/tuple/eat.hpp"
#line 23 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 24 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/tuple/elem.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/tuple/elem.hpp"
#line 25 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/tuple/rem.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/tuple/rem.hpp"
#line 26 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/enum.hpp"
#line 11 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/enum_params.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum_params.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum_params.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/punctuation/comma_if.hpp"
#line 20 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum_params.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 21 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/enum_params.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/enum_params.hpp"
#line 12 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 13 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/repeat.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/repetition/repeat.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/repeat.hpp"
#line 14 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/inc.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/arithmetic/inc.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/config/config.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/arithmetic/inc.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/inc.hpp"
#line 15 "/net/cci/rwgk/dist/boost/boost/function/detail/prologue.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/function/function_template.hpp"































#line 69 "/net/cci/rwgk/dist/boost/boost/function/function_template.hpp"

namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R 
        
        >
      struct function_invoker0
      {
        static R invoke(any_pointer function_ptr 
                        )
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f();
        }
      };

      template<
        typename FunctionPtr,
        typename R 
        
        >
      struct void_function_invoker0
      {
        static unusable invoke(any_pointer function_ptr 
                               )

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          f();
          return unusable();
        }
      };

      template<
        typename FunctionObj,
        typename R 
        
      >
      struct function_obj_invoker0
      {
        static R invoke(any_pointer function_obj_ptr 
                        )

        {
          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R 
        
      >
      struct void_function_obj_invoker0
      {
        static unusable invoke(any_pointer function_obj_ptr
                               
                               )

        {
          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
          (*f)();
          return unusable();
        }
      };

      template<
        typename FunctionObj,
        typename R 
        
      >
      struct stateless_function_obj_invoker0
      {
        static R invoke(any_pointer  )
        {
          FunctionObj f = FunctionObj();
          return f();
        }
      };

      template<
        typename FunctionObj,
        typename R 
        
      >
      struct stateless_void_function_obj_invoker0
      {
        static unusable invoke(any_pointer 
                               )

        {
          FunctionObj f = FunctionObj();
          f();
          return unusable();
        }
      };

      template<
        typename FunctionPtr,
        typename R 
        
      >
      struct get_function_invoker0
      {
        typedef typename ct_if<(is_void<R>::value),
                            void_function_invoker0<
                            FunctionPtr,
                            R 
                            
                          >,
                          function_invoker0<
                            FunctionPtr,
                            R 
                            
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R 
        
       >
      struct get_function_obj_invoker0
      {
        typedef typename ct_if<(is_void<R>::value),
                            void_function_obj_invoker0<
                            FunctionObj,
                            R 
                            
                          >,
                          function_obj_invoker0<
                            FunctionObj,
                            R 
                            
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R 
        
       >
      struct get_stateless_function_obj_invoker0
      {
        typedef typename ct_if<(is_void<R>::value),
                            stateless_void_function_obj_invoker0<
                            FunctionObj,
                            R 
                            
                          >,
                          stateless_function_obj_invoker0<
                            FunctionObj,
                            R 
                            
                          >
                       >::type type;
      };

    } 
  } 

  template<
    typename R 
    ,
    typename Allocator = std::allocator<function_base>
  >
  class function0 : public function_base
  {
    typedef typename detail::function::function_return_type<R>::type
      internal_result_type;

    struct clear_type {};

  public:
    static const int args = 0;

    
    template<typename Args>
    struct sig
    {
      typedef internal_result_type type;
    };

#line 264 "/net/cci/rwgk/dist/boost/boost/function/function_template.hpp"

    static const int arity = 0;
    


    typedef R         result_type;



    typedef Allocator allocator_type;
    typedef function0 self_type;

    function0() : function_base()
                              , invoker(0) {}

    
    
    template<typename Functor>
    function0(Functor  f

                            ,typename detail::function::enable_if<
                                        (!is_same<Functor, int>::value),
                                        int>::type = 0

                            ) :
      function_base(),
      invoker(0)
    {
      this->assign_to(f);
    }


    function0(clear_type*) : function_base(), invoker(0) {}


    function0(const function0& f) :
      function_base(),
      invoker(0)
    {
      this->assign_to_own(f);
    }

    ~function0() { clear(); }

    result_type operator()() const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      internal_result_type result = invoker(function_base::functor
                                            
                                            );


      return static_cast<result_type>(result);



    }

    
    
    
    
    
    template<typename Functor>

    typename detail::function::enable_if<
               (!is_same<Functor, int>::value),
               function0&>::type



    operator=(Functor  f)
    {
      self_type(f).swap(*this);
      return *this;
    }


    function0& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }


    
    function0& operator=(const function0& f)
    {
      if (&f == this)
        return *this;

      self_type(f).swap(*this);
      return *this;
    }

    void swap(function0& other)
    {
      if (&other == this)
        return;

      std::swap(function_base::manager, other.manager);
      std::swap(function_base::functor, other.functor);
      std::swap(invoker, other.invoker);
    }

    
    void clear()
    {
      if (function_base::manager) {
        function_base::functor =
          function_base::manager(function_base::functor,
                                 detail::function::destroy_functor_tag);
      }

      function_base::manager = 0;
      invoker = 0;
    }





  private:
    struct dummy {
      void nonnull() {};
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function0& f)
    {
      if (!f.empty()) {
        invoker = f.invoker;
        function_base::manager = f.manager;
        function_base::functor =
          f.manager(f.functor, detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      typedef typename detail::function::get_function_tag<Functor>::type tag;
      this->assign_to(f, tag());
    }

    template<typename FunctionPtr>
    void assign_to(FunctionPtr f, detail::function::function_ptr_tag)
    {
      clear();

      if (f) {
        typedef typename detail::function::get_function_invoker0<
                           FunctionPtr,
                           R 
                           
                         >::type
          invoker_type;

        invoker = &invoker_type::invoke;
        function_base::manager =
          &detail::function::functor_manager<FunctionPtr, Allocator>::manage;
        function_base::functor =
          function_base::manager(detail::function::make_any_pointer(
                            
                            
                            (void (*)())(f)
                          ),
                          detail::function::clone_functor_tag);
      }
    }

#line 454 "/net/cci/rwgk/dist/boost/boost/function/function_template.hpp"

    template<typename FunctionObj>
    void assign_to(FunctionObj f, detail::function::function_obj_tag)
    {
      if (!detail::function::has_empty_target(addressof(f))) {
        typedef
          typename detail::function::get_function_obj_invoker0<
                                       FunctionObj,
                                       R 
                                       
                                     >::type
          invoker_type;

        invoker = &invoker_type::invoke;
        function_base::manager = &detail::function::functor_manager<
                                    FunctionObj, Allocator>::manage;

        typedef typename Allocator::template rebind<FunctionObj>::other
          allocator_type;
        typedef typename allocator_type::pointer pointer_type;
        allocator_type allocator;
        pointer_type copy = allocator.allocate(1);
        allocator.construct(copy, f);

        
        FunctionObj* new_f = static_cast<FunctionObj*>(copy);



        function_base::functor =
          detail::function::make_any_pointer(static_cast<void*>(new_f));
      }
    }

    template<typename FunctionObj>
    void assign_to(const reference_wrapper<FunctionObj>& f,
                   detail::function::function_obj_ref_tag)
    {
      if (!detail::function::has_empty_target(f.get_pointer())) {
        typedef
          typename detail::function::get_function_obj_invoker0<
                                       FunctionObj,
                                       R 
                                       
                                     >::type
          invoker_type;

        invoker = &invoker_type::invoke;
        function_base::manager = &detail::function::trivial_manager;
        function_base::functor =
          function_base::manager(
            detail::function::make_any_pointer(
              const_cast<FunctionObj*>(f.get_pointer())),
            detail::function::clone_functor_tag);
      }
    }

    template<typename FunctionObj>
    void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
    {
      typedef
          typename detail::function::
                     get_stateless_function_obj_invoker0<
                       FunctionObj,
                       R 
                       
                     >::type
          invoker_type;
      invoker = &invoker_type::invoke;
      function_base::manager = &detail::function::trivial_manager;
      function_base::functor = detail::function::make_any_pointer(this);
    }

    typedef internal_result_type (*invoker_type)(detail::function::any_pointer
                                                 
                                                 );

    invoker_type invoker;
  };

  template<typename R   ,
           typename Allocator>
  inline void swap(function0<
                     R 
                      ,
                     Allocator
                   >& f1,
                   function0<
                     R 
                     ,
                     Allocator
                   >& f2)
  {
    f1.swap(f2);
  }









template<typename R 
         ,
         typename Allocator>
class function<R (void), Allocator>
  : public function0<R, 
                                    Allocator>
{
  typedef function0<R, 
                                   Allocator> base_type;
  typedef function self_type;

  struct clear_type {};

public:
  typedef typename base_type::allocator_type allocator_type;

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename detail::function::enable_if<
                       (!is_same<Functor, int>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

  template<typename Functor>

  typename detail::function::enable_if<
                      (!is_same<Functor, int>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }
};




} 


#line 5 "/net/cci/rwgk/dist/boost/boost/function/detail/maybe_include.hpp"
#line 3 "/net/cci/rwgk/dist/boost/boost/function/function0.hpp"
#line 15 "/net/cci/rwgk/dist/boost/boost/python/errors.hpp"

namespace boost { namespace python {

struct  error_already_set {};
struct  argument_error : error_already_set {};



 bool handle_exception_impl(function0<void>);

template <class T>
bool handle_exception(T f)
{
    return handle_exception_impl(function0<void>(boost::ref(f)));
}

namespace detail { inline void rethrow() { throw; } }

inline void handle_exception()
{
    handle_exception(detail::rethrow);
}

 void throw_argument_error();
 void throw_error_already_set();

template <class T>
inline T* expect_non_null(T* x)
{
    if (x == 0)
        throw_error_already_set();
    return x;
}



 PyObject* pytype_check(PyTypeObject* pytype, PyObject* source);

}} 

#line 12 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/borrowed.hpp"





#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/borrowed_ptr.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/if.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/value_wknd.hpp"





















#line 37 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/value_wknd.hpp"





#line 20 "/net/cci/rwgk/dist/boost/boost/mpl/if.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/lambda_fwd.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/lambda_arity_param.hpp"



























#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/lambda_fwd.hpp"


namespace boost {
namespace mpl {


template< typename T  >
struct lambda;




} 
} 

#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/void.hpp"






















namespace boost {
namespace mpl {

struct void_;

template< typename T >
struct is_void_
    : false_c
{



};

template<>
struct is_void_<void_>
    : true_c
{



};

} 
} 

#line 22 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/enum.hpp"




























#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/cat.hpp"
#line 30 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/enum.hpp"




    
#line 45 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/enum.hpp"

#line 64 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/enum.hpp"

#line 24 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/limits/arity.hpp"























#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/dtp.hpp"

































#line 40 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/config/dtp.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/identity.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/facilities/identity.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/facilities/empty.hpp"
#line 19 "/net/cci/rwgk/dist/boost/boost/preprocessor/facilities/identity.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/identity.hpp"
#line 25 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/empty.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/preprocessor/facilities/empty.hpp"
#line 17 "/net/cci/rwgk/dist/boost/boost/preprocessor/empty.hpp"
#line 26 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"







#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/filter_params.hpp"



















#line 30 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/filter_params.hpp"

#line 34 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/sub.hpp"



















#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/tuple.hpp"



















#line 31 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/tuple.hpp"

#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/sub.hpp"


#line 37 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/sub.hpp"






#line 54 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/sub.hpp"

#line 35 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"

#line 44 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"









#line 62 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"

#line 88 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"





#line 102 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp"

#line 25 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/arity.hpp"





















#line 44 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/arity.hpp"

#line 26 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"
#line 32 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"







#line 57 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"

#line 72 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"

#line 96 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"

#line 122 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"




#line 132 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"

#line 139 "/net/cci/rwgk/dist/boost/boost/mpl/aux_/void_spec.hpp"

#line 21 "/net/cci/rwgk/dist/boost/boost/mpl/if.hpp"



namespace boost {
namespace mpl {



template<
      bool C
    , typename T1
    , typename T2
    >
struct if_c
{
    typedef T1 type;
};

template<
      typename T1
    , typename T2
    >
struct if_c<false,T1,T2>
{
    typedef T2 type;
};

template<
      typename C = void_
    , typename T1 = void_
    , typename T2 = void_
    >
struct if_
{
    typedef typename if_c<
          C::value
        , T1
        , T2
        >::type type;

    
};

#line 157 "/net/cci/rwgk/dist/boost/boost/mpl/if.hpp"

template< > struct if_< void_,void_,void_ > { template< typename T1,typename T2,typename T3 , typename T4 =void_ ,typename T5 =void_  > struct apply : if_< T1,T2,T3 > { }; }; template< > struct lambda< if_< void_,void_,void_ >  > { typedef if_< void_,void_,void_ > type; };  

} 
} 

#line 12 "/net/cci/rwgk/dist/boost/boost/python/detail/borrowed_ptr.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"

















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_assign.hpp"












#line 21 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_assign.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 24 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_assign.hpp"

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_assign_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_POD<T> ::value, false > ::value, ::boost::type_traits::ice_not< ::boost::is_const<T> ::value > ::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T> ::value > ::value > ::value);
#line 41 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_assign.hpp"
};

} 

template< typename T > struct has_trivial_assign : mpl::bool_c< ::boost::detail::has_trivial_assign_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 50 "/net/cci/rwgk/dist/boost/boost/type_traits/has_trivial_assign.hpp"

#line 19 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_constructor.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_constructor.hpp"

namespace boost {

template< typename T > struct has_nothrow_constructor : mpl::bool_c< ::boost::has_trivial_constructor<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 25 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_constructor.hpp"

#line 23 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_copy.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_copy.hpp"

namespace boost {

template< typename T > struct has_nothrow_copy : mpl::bool_c< ::boost::has_trivial_copy<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 25 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_copy.hpp"

#line 24 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_assign.hpp"















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 17 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_assign.hpp"

namespace boost {

template< typename T > struct has_nothrow_assign : mpl::bool_c< ::boost::has_trivial_assign<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 25 "/net/cci/rwgk/dist/boost/boost/type_traits/has_nothrow_assign.hpp"

#line 25 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_base_and_derived.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/is_base_and_derived.hpp"

namespace boost {

namespace detail {

template <typename Base, typename Derived>
struct is_base_and_derived_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::is_convertible<Derived*,Base* > ::value, ::boost::is_class<Derived> ::value, ::boost::is_class<Base> ::value > ::value);
#line 35 "/net/cci/rwgk/dist/boost/boost/type_traits/is_base_and_derived.hpp"
};

} 






template< typename Base, typename Derived > struct is_base_and_derived : mpl::bool_c< (::boost::detail::is_base_and_derived_impl<Base,Derived> ::value) > {   }; 


template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : mpl::bool_c< false > {  };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : mpl::bool_c< false > {  };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : mpl::bool_c< false > {  };


} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 55 "/net/cci/rwgk/dist/boost/boost/type_traits/is_base_and_derived.hpp"

#line 26 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_compound.hpp"












#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/is_compound.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 25 "/net/cci/rwgk/dist/boost/boost/type_traits/is_compound.hpp"

namespace boost {

namespace detail {

template <typename T>
struct is_compound_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_array<T> ::value, ::boost::is_pointer<T> ::value, ::boost::is_reference<T> ::value, ::boost::is_class<T> ::value, ::boost::is_union<T> ::value, ::boost::is_enum<T> ::value, ::boost::is_member_pointer<T> ::value > ::value);
#line 43 "/net/cci/rwgk/dist/boost/boost/type_traits/is_compound.hpp"
};

} 

template< typename T > struct is_compound : mpl::bool_c< ::boost::detail::is_compound_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 52 "/net/cci/rwgk/dist/boost/boost/type_traits/is_compound.hpp"

#line 28 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/is_object.hpp"












#line 19 "/net/cci/rwgk/dist/boost/boost/type_traits/is_object.hpp"


#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"


















#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/template_arity_spec.hpp"
























#line 20 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"




#line 31 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 38 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"









#line 57 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 68 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 77 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 86 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 94 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 102 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 111 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 119 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_def.hpp"

#line 22 "/net/cci/rwgk/dist/boost/boost/type_traits/is_object.hpp"

namespace boost {

namespace detail {

template <typename T>
struct is_object_impl
{

   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T> ::value> ::value, ::boost::type_traits::ice_not< ::boost::is_void<T> ::value> ::value, ::boost::type_traits::ice_not< ::boost::is_function<T> ::value> ::value > ::value);
#line 44 "/net/cci/rwgk/dist/boost/boost/type_traits/is_object.hpp"
};

} 

template< typename T > struct is_object : mpl::bool_c< ::boost::detail::is_object_impl<T> ::value > {   }; 

} 

#line 1 "/net/cci/rwgk/dist/boost/boost/type_traits/detail/bool_trait_undef.hpp"


















#line 53 "/net/cci/rwgk/dist/boost/boost/type_traits/is_object.hpp"

#line 30 "/net/cci/rwgk/dist/boost/boost/type_traits/object_traits.hpp"




#line 13 "/net/cci/rwgk/dist/boost/boost/python/detail/borrowed_ptr.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/tag.hpp"








namespace boost { namespace python { 



enum tag_t { tag };

}} 

#line 15 "/net/cci/rwgk/dist/boost/boost/python/detail/borrowed_ptr.hpp"

namespace boost { namespace python { namespace detail {

template<class T> class borrowed
{ 
    typedef T type;
};


template<typename T>
struct is_borrowed_ptr
{
    static const bool value = false; 
};


template<typename T>
struct is_borrowed_ptr<borrowed<T>*>
{
    static const bool value = true;
};

template<typename T>
struct is_borrowed_ptr<borrowed<T> const*>
{
    static const bool value = true;
};

template<typename T>
struct is_borrowed_ptr<borrowed<T> volatile*>
{
    static const bool value = true;
};

template<typename T>
struct is_borrowed_ptr<borrowed<T> const volatile*>
{
    static const bool value = true;
};
#line 71 "/net/cci/rwgk/dist/boost/boost/python/detail/borrowed_ptr.hpp"

#line 101 "/net/cci/rwgk/dist/boost/boost/python/detail/borrowed_ptr.hpp"

}

template <class T>
inline T* get_managed_object(detail::borrowed<T> const volatile* p, tag_t)
{
    return (T*)p;
}

}} 

#line 9 "/net/cci/rwgk/dist/boost/boost/python/borrowed.hpp"

namespace boost { namespace python { 

template <class T>
inline python::detail::borrowed<T>* borrowed(T* p)
{
    return (detail::borrowed<T>*)p;
}
    
}} 

#line 13 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/handle_fwd.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/handle_fwd.hpp"

namespace boost { namespace python { 

template <class T = PyObject> class handle;

}} 

#line 14 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/refcount.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/refcount.hpp"


namespace boost { namespace python { 

template <class T>
inline T* incref(T* p)
{
    ((python::upcast<PyObject>(p))->ob_refcnt++);
    return p;
}

template <class T>
inline T* xincref(T* p)
{
    if ((python::upcast<PyObject>(p)) == 0L) ; else ((python::upcast<PyObject>(p))->ob_refcnt++);
    return p;
}

template <class T>
inline void decref(T* p)
{
    if (--(python::upcast<PyObject>(p))->ob_refcnt != 0) ; else (*((PyObject *)(python::upcast<PyObject>(p)))->ob_type ->tp_dealloc)((PyObject *)((PyObject *)(python::upcast<PyObject>(p))));
}

template <class T>
inline void xdecref(T* p)
{
    if ((python::upcast<PyObject>(p)) == 0L) ; else if (--(python::upcast<PyObject>(p))->ob_refcnt != 0) ; else (*((PyObject *)(python::upcast<PyObject>(p)))->ob_type ->tp_dealloc)((PyObject *)((PyObject *)(python::upcast<PyObject>(p))));
}

}} 

#line 15 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/raw_pyobject.hpp"








namespace boost { namespace python { namespace detail { 










struct new_reference_t;
typedef new_reference_t* new_reference;


struct borrowed_reference_t;
typedef borrowed_reference_t* borrowed_reference;


struct new_non_null_reference_t;
typedef new_non_null_reference_t* new_non_null_reference;

}}} 

#line 17 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"

namespace boost { namespace python { 

template <class T> struct null_ok;

template <class T>
inline null_ok<T>* allow_null(T* p)
{
    return (null_ok<T>*)p;
}

namespace detail
{
  template <class T>
  inline T* manage_ptr(detail::borrowed<null_ok<T> >* p, int)
  {
      return python::xincref((T*)p);
  }
  
  template <class T>
  inline T* manage_ptr(null_ok<detail::borrowed<T> >* p, int)
  {
      return python::xincref((T*)p);
  }
  
  template <class T>
  inline T* manage_ptr(detail::borrowed<T>* p, long)
  {
      return python::incref(expect_non_null((T*)p));
  }
  
  template <class T>
  inline T* manage_ptr(null_ok<T>* p, long)
  {
      return (T*)p;
  }
  
  template <class T>
  inline T* manage_ptr(T* p, ...)
  {
      return expect_non_null(p);
  }
}

template <class T>
class handle
{
    typedef T* (handle::* bool_type )() const;

 public: 
    typedef T element_type;
    
 public: 
    handle();
    ~handle();

    template <class Y>
    explicit handle(Y* p)
        : m_p(
            python::upcast<T>(
                detail::manage_ptr(p, 0)
                )
            )
    {
    }

    handle& operator=(handle const& r);



    template<typename Y>
    handle& operator=(handle<Y> const & r) 
    {
        python::xdecref(m_p);
        m_p = python::xincref(python::upcast<T>(r.get()));
        return *this;
    }



    template <typename Y>
    handle(handle<Y> const& r)
        : m_p(python::xincref(python::upcast<T>(r.get())))
    {
    }
    
    handle(handle const& r)
        : m_p(python::xincref(r.m_p))
    {
    }
    
    T* operator-> () const;
    T& operator* () const;
    T* get() const;
    T* release();
    
    operator bool_type() const 
    {
        return m_p ? &handle<T>::get : 0;
    }
    bool operator! () const; 

 public: 
    
    inline handle(detail::borrowed_reference x)
        : m_p(
            python::incref(
                downcast<T>((PyObject*)x)
                ))
    {
    }
    
 private: 
    T* m_p;
};

typedef handle<PyTypeObject> type_handle;





template<typename T>
class is_handle
{
 public:
    static const bool value = false; 
};

template<typename T>
class is_handle<handle<T> >
{
 public:
    static const bool value = true;
};
#line 174 "/net/cci/rwgk/dist/boost/boost/python/handle.hpp"




template <class T>
inline handle<T>::handle()
    : m_p(0)
{
}

template <class T>
inline handle<T>::~handle()
{
    python::xdecref(m_p);
}

template <class T>
inline handle<T>& handle<T>::operator=(handle<T> const& r)
{
    python::xdecref(m_p);
    m_p = python::xincref(r.m_p);
    return *this;
}

template <class T>
inline T* handle<T>::operator->() const
{
    return m_p;
}

template <class T>
inline T& handle<T>::operator*() const
{
    return *m_p;
}

template <class T>
inline T* handle<T>::get() const
{
    return m_p;
}
    
template <class T>
inline bool handle<T>::operator!() const
{
    return m_p == 0;
}

template <class T>
inline T* handle<T>::release()
{
    T* result = m_p;
    m_p = 0;
    return result;
}



template <class T>
inline PyObject* get_managed_object(handle<T> const& h, tag_t)
{
    return h.get() ? python::upcast<PyObject>(h.get()) : (&_Py_NoneStruct);
}

}} 


#line 11 "/net/cci/rwgk/dist/boost/boost/python/converter/arg_to_python_base.hpp"

namespace boost { namespace python { namespace converter {

struct registration;

namespace detail
{
  struct  arg_to_python_base

      : handle<>

  {
      arg_to_python_base(void const volatile* source, registration const&);
#line 30 "/net/cci/rwgk/dist/boost/boost/python/converter/arg_to_python_base.hpp"
  };
}

}}} 

#line 8 "/net/cci/rwgk/dist/boost/libs/python/src/converter/arg_to_python_base.cpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/converter/registrations.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/converter/registrations.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/converter/convertible_function.hpp"








namespace boost { namespace python { namespace converter { 

typedef void* (*convertible_function)(PyObject*);
    
}}} 

#line 11 "/net/cci/rwgk/dist/boost/boost/python/converter/registrations.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/converter/constructor_function.hpp"








namespace boost { namespace python { namespace converter { 



struct rvalue_from_python_stage1_data;
typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);

}}} 

#line 12 "/net/cci/rwgk/dist/boost/boost/python/converter/registrations.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/type_id.hpp"








#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"


























#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"










 





#line 34 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/limits.h"



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx_cname/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 28 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"
#line 37 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




#line 1 "/usr/local_cci/Python-2.2.1t/include/python2.2/patchlevel.h"











 

 




					 

 






 



 
#line 42 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"

#line 49 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"





#line 117 "/net/cci/rwgk/dist/boost/boost/python/detail/wrap_python.hpp"




































#line 10 "/net/cci/rwgk/dist/boost/boost/python/type_id.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/python/detail/msvc_typeinfo.hpp"








#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/typeinfo"
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_prologue.h"


















 


 

#pragma __environment save
#pragma __environment header_defaults
#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/typeinfo"













 

 


 







#      pragma __environment __save
#      pragma __environment __cxx_header_defaults









namespace std {



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


  protected:
    
    

    type_info(const type_info&);  
  };

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

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


}   








#      pragma __environment __restore



#line 1 "/usr/lib/cmplrs/cxx/V6.5-031/include/cxx/__DECC_include_epilogue.h"


















 


 

#pragma __environment restore
#line 11 "/net/cci/rwgk/dist/boost/boost/python/detail/msvc_typeinfo.hpp"










#line 12 "/net/cci/rwgk/dist/boost/boost/python/type_id.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/operators.hpp"














































































#line 1 "/net/cci/rwgk/dist/boost/boost/iterator.hpp"





















namespace boost
{
#line 37 "/net/cci/rwgk/dist/boost/boost/iterator.hpp"

  
  
  namespace detail {
   template <class Category, class T, class Distance, class Pointer, class Reference>

   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
#line 52 "/net/cci/rwgk/dist/boost/boost/iterator.hpp"
  }

  template <class Category, class T, class Distance = std::ptrdiff_t,
            class Pointer = T*, class Reference = T&>
   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};

} 

#line 81 "/net/cci/rwgk/dist/boost/boost/operators.hpp"









namespace boost {
namespace detail {







class empty_base {};


} 
} 









namespace boost
{







template <class T, class U, class B = ::boost::detail::empty_base>
struct less_than_comparable2 : B
{
     friend bool operator<=(const T& x, const U& y) { return !(x > y); }
     friend bool operator>=(const T& x, const U& y) { return !(x < y); }
     friend bool operator>(const U& x, const T& y)  { return y < x; }
     friend bool operator<(const U& x, const T& y)  { return y > x; }
     friend bool operator<=(const U& x, const T& y) { return !(y < x); }
     friend bool operator>=(const U& x, const T& y) { return !(y > x); }
};

template <class T, class B = ::boost::detail::empty_base>
struct less_than_comparable1 : B
{
     friend bool operator>(const T& x, const T& y)  { return y < x; }
     friend bool operator<=(const T& x, const T& y) { return !(y < x); }
     friend bool operator>=(const T& x, const T& y) { return !(x < y); }
};

template <class T, class U, class B = ::boost::detail::empty_base>
struct equality_comparable2 : B
{
     friend bool operator==(const U& y, const T& x) { return x == y; }
     friend bool operator!=(const U& y, const T& x) { return !(x == y); }
     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
};

template <class T, class B = ::boost::detail::empty_base>
struct equality_comparable1 : B
{
     friend bool operator!=(const T& x, const T& y) { return !(x == y); }
};



#line 204 "/net/cci/rwgk/dist/boost/boost/operators.hpp"





#line 222 "/net/cci/rwgk/dist/boost/boost/operators.hpp"

#line 242 "/net/cci/rwgk/dist/boost/boost/operators.hpp"



template <class T, class U, class B = ::boost::detail::empty_base> struct multipliable2 : B { friend T operator *( T lhs, const U& rhs ) { return lhs *= rhs; } friend T operator *( const U& lhs, T rhs ) { return rhs *= lhs; } }; template <class T, class B = ::boost::detail::empty_base> struct multipliable1 : B { friend T operator *( T lhs, const T& rhs ) { return lhs *= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct addable2 : B { friend T operator +( T lhs, const U& rhs ) { return lhs += rhs; } friend T operator +( const U& lhs, T rhs ) { return rhs += lhs; } }; template <class T, class B = ::boost::detail::empty_base> struct addable1 : B { friend T operator +( T lhs, const T& rhs ) { return lhs += rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct subtractable2 : B { friend T operator -( T lhs, const U& rhs ) { return lhs -= rhs; } }; template <class T, class U, class B = ::boost::detail::empty_base> struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { return T( lhs ) -= rhs; } }; template <class T, class B = ::boost::detail::empty_base> struct subtractable1 : B { friend T operator -( T lhs, const T& rhs ) { return lhs -= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct dividable2 : B { friend T operator /( T lhs, const U& rhs ) { return lhs /= rhs; } }; template <class T, class U, class B = ::boost::detail::empty_base> struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { return T( lhs ) /= rhs; } }; template <class T, class B = ::boost::detail::empty_base> struct dividable1 : B { friend T operator /( T lhs, const T& rhs ) { return lhs /= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct modable2 : B { friend T operator %( T lhs, const U& rhs ) { return lhs %= rhs; } }; template <class T, class U, class B = ::boost::detail::empty_base> struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { return T( lhs ) %= rhs; } }; template <class T, class B = ::boost::detail::empty_base> struct modable1 : B { friend T operator %( T lhs, const T& rhs ) { return lhs %= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct xorable2 : B { friend T operator ^( T lhs, const U& rhs ) { return lhs ^= rhs; } friend T operator ^( const U& lhs, T rhs ) { return rhs ^= lhs; } }; template <class T, class B = ::boost::detail::empty_base> struct xorable1 : B { friend T operator ^( T lhs, const T& rhs ) { return lhs ^= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct andable2 : B { friend T operator &( T lhs, const U& rhs ) { return lhs &= rhs; } friend T operator &( const U& lhs, T rhs ) { return rhs &= lhs; } }; template <class T, class B = ::boost::detail::empty_base> struct andable1 : B { friend T operator &( T lhs, const T& rhs ) { return lhs &= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct orable2 : B { friend T operator |( T lhs, const U& rhs ) { return lhs |= rhs; } friend T operator |( const U& lhs, T rhs ) { return rhs |= lhs; } }; template <class T, class B = ::boost::detail::empty_base> struct orable1 : B { friend T operator |( T lhs, const T& rhs ) { return lhs |= rhs; } };






template <class T, class B = ::boost::detail::empty_base>
struct incrementable : B
{
  friend T operator++(T& x, int)
  {
    incrementable_type nrv(x);
    ++x;
    return nrv;
  }
private: 
  typedef T incrementable_type;
};

template <class T, class B = ::boost::detail::empty_base>
struct decrementable : B
{
  friend T operator--(T& x, int)
  {
    decrementable_type nrv(x);
    --x;
    return nrv;
  }
private: 
  typedef T decrementable_type;
};



template <class T, class P, class B = ::boost::detail::empty_base>
struct dereferenceable : B
{
  P operator->() const
  { 
    return &*static_cast<const T&>(*this); 
  }
};

template <class T, class I, class R, class B = ::boost::detail::empty_base>
struct indexable : B
{
  R operator[](I n) const
  {
    return *(static_cast<const T&>(*this) + n);
  }
};




#line 326 "/net/cci/rwgk/dist/boost/boost/operators.hpp"

#line 339 "/net/cci/rwgk/dist/boost/boost/operators.hpp"



template <class T, class U, class B = ::boost::detail::empty_base> struct left_shiftable2 : B { friend T operator <<( T lhs, const U& rhs ) { return lhs <<= rhs; } }; template <class T, class B = ::boost::detail::empty_base> struct left_shiftable1 : B { friend T operator <<( T lhs, const T& rhs ) { return lhs <<= rhs; } };
template <class T, class U, class B = ::boost::detail::empty_base> struct right_shiftable2 : B { friend T operator >>( T lhs, const U& rhs ) { return lhs >>= rhs; } }; template <class T, class B = ::boost::detail::empty_base> struct right_shiftable1 : B { friend T operator >>( T lhs, const T& rhs ) { return lhs >>= rhs; } };



template <class T, class U, class B = ::boost::detail::empty_base>
struct equivalent2 : B
{
  friend bool operator==(const T& x, const U& y)
  {
    return !(x < y) && !(x > y);
  }
};

template <class T, class B = ::boost::detail::empty_base>
struct equivalent1 : B
{
  friend bool operator==(const T&x, const T&y)
  {
    return !(x < y) && !(y < x);
  }
};

template <class T, class U, class B = ::boost::detail::empty_base>
struct partially_ordered2 : B
{
  friend bool operator<=(const T& x, const U& y)
    { return (x < y) || (x == y); }
  friend bool operator>=(const T& x, const U& y)
    { return (x > y) || (x == y); }
  friend bool operator>(const U& x, const T& y)
    { return y < x; }
  friend bool operator<(const U& x, const T& y)
    { return y > x; }
  friend bool operator<=(const U& x, const T& y)
    { return (y > x) || (y == x); }
  friend bool operator>=(const U& x, const T& y)
    { return (y < x) || (y == x); }
};

template <class T, class B = ::boost::detail::empty_base>
struct partially_ordered1 : B
{
  friend bool operator>(const T& x, const T& y)
    { return y < x; }
  friend bool operator<=(const T& x, const T& y)
    { return (x < y) || (x == y); }
  friend bool operator>=(const T& x, const T& y)
    { return (y < x) || (x == y); }
};



template <class T, class U, class B = ::boost::detail::empty_base>
struct totally_ordered2
    : less_than_comparable2<T, U
    , equality_comparable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct totally_ordered1
    : less_than_comparable1<T
    , equality_comparable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct additive2
    : addable2<T, U
    , subtractable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct additive1
    : addable1<T
    , subtractable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct multiplicative2
    : multipliable2<T, U
    , dividable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct multiplicative1
    : multipliable1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct integer_multiplicative2
    : multiplicative2<T, U
    , modable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct integer_multiplicative1
    : multiplicative1<T
    , modable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct arithmetic2
    : additive2<T, U
    , multiplicative2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct arithmetic1
    : additive1<T
    , multiplicative1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct integer_arithmetic2
    : additive2<T, U
    , integer_multiplicative2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct integer_arithmetic1
    : additive1<T
    , integer_multiplicative1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct bitwise2
    : xorable2<T, U
    , andable2<T, U
    , orable2<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base>
struct bitwise1
    : xorable1<T
    , andable1<T
    , orable1<T, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base>
struct unit_steppable
    : incrementable<T
    , decrementable<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct shiftable2
    : left_shiftable2<T, U
    , right_shiftable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct shiftable1
    : left_shiftable1<T
    , right_shiftable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct ring_operators2
    : additive2<T, U
    , subtractable2_left<T, U
    , multipliable2<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base>
struct ring_operators1
    : additive1<T
    , multipliable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct ordered_ring_operators2
    : ring_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct ordered_ring_operators1
    : ring_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct field_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base>
struct field_operators1
    : ring_operators1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct ordered_field_operators2
    : field_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct ordered_field_operators1
    : field_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct euclidian_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = ::boost::detail::empty_base>
struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = ::boost::detail::empty_base>
struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base>
struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};
      
template <class T, class P, class B = ::boost::detail::empty_base>
struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base>
struct output_iteratable
    : incrementable<T, B
      > {};

template <class T, class P, class B = ::boost::detail::empty_base>
struct forward_iteratable
    : input_iteratable<T, P, B
      > {};

template <class T, class P, class B = ::boost::detail::empty_base>
struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
      > > {};





template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
    , additive2<T, D
    , indexable<T, D, R, B
      > > > > {};


} 













  





#line 667 "/net/cci/rwgk/dist/boost/boost/operators.hpp"













namespace boost {


namespace detail {
  struct true_t {};
  struct false_t {};
} 




template<class T> struct is_chained_base {
  typedef ::boost::detail::false_t value;
};

} 



#line 705 "/net/cci/rwgk/dist/boost/boost/operators.hpp"



#line 714 "/net/cci/rwgk/dist/boost/boost/operators.hpp"



#line 723 "/net/cci/rwgk/dist/boost/boost/operators.hpp"



#line 732 "/net/cci/rwgk/dist/boost/boost/operators.hpp"















#line 770 "/net/cci/rwgk/dist/boost/boost/operators.hpp"


#line 790 "/net/cci/rwgk/dist/boost/boost/operators.hpp"

namespace boost {
    
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };

 template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };

 template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };

template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };

template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base ,class O = typename is_chained_base<U> ::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; };  template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; };  template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };

#line 848 "/net/cci/rwgk/dist/boost/boost/operators.hpp"



template <class T, class U>
struct operators2
    : totally_ordered2<T,U
    , integer_arithmetic2<T,U
    , bitwise2<T,U
      > > > {};


template <class T, class U = T>
struct operators : operators2<T, U> {};

template <class T> struct operators<T, T>



    : totally_ordered<T
    , integer_arithmetic<T
    , bitwise<T
    , unit_steppable<T
      > > > > {};




template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V const *,
          class R = V const &>
struct input_iterator_helper
  : input_iteratable<T, P
  , boost::iterator<std::input_iterator_tag, V, D, P, R
    > > {};

template<class T>
struct output_iterator_helper
  : output_iteratable<T
  , boost::iterator<std::output_iterator_tag, void, void, void, void
  > >
{
  T& operator*()  { return static_cast<T&>(*this); }
  T& operator++() { return static_cast<T&>(*this); }
};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct forward_iterator_helper
  : forward_iteratable<T, P
  , boost::iterator<std::forward_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct bidirectional_iterator_helper
  : bidirectional_iteratable<T, P
  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V, 
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct random_access_iterator_helper
  : random_access_iteratable<T, P, D, R
  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
    > >
{
  friend D requires_difference_operator(const T& x, const T& y) {
    return x - y;
  }
}; 

} 





#line 13 "/net/cci/rwgk/dist/boost/boost/python/type_id.hpp"
#line 1 "/net/cci/rwgk/dist/boost/boost/static_assert.hpp"












 












namespace boost{


template <bool x> struct STATIC_ASSERTION_FAILURE;

template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };


template<int x> struct static_assert_test{};

}

























#line 76 "/net/cci/rwgk/dist/boost/boost/static_assert.hpp"







#line 89 "/net/cci/rwgk/dist/boost/boost/static_assert.hpp"


#line 16 "/net/cci/rwgk/dist/boost/boost/python/type_id.hpp"


namespace boost { namespace python { 













struct type_info : private totally_ordered<type_info>
{
    inline type_info(std::type_info const& = typeid(void));
    
    inline bool operator<(type_info const& rhs) const;
    inline bool operator==(type_info const& rhs) const;

    char const* name() const;
    friend  std::ostream& operator<<(
        std::ostream&, type_info const&);
    
 private: 



    typedef std::type_info const* base_id_t;

    
    base_id_t m_base_type;
};

template <class T>
inline type_info type_id(boost::type<T>* = 0)
{
    return type_info(

        typeid(T)



        );
}

#line 89 "/net/cci/rwgk/dist/boost/boost/python/type_id.hpp"


inline type_info::type_info(std::type_info const& id)
    : m_base_type(



        &id

        )
{
}

inline bool type_info::operator<(type_info const& rhs) const
{



    return m_base_type->before(*rhs.m_base_type);

}

inline bool type_info::operator==(type_info const& rhs) const
{



    return *m_base_type == *rhs.m_base_type;

}

inline char const* type_info::name() const
{



    return m_base_type->name();

}


 std::ostream& operator<<(std::ostream&, type_info const&);

}} 

#line 14 "/net/cci/rwgk/dist/boost/boost/python/converter/registrations.hpp"

namespace boost { namespace python { namespace converter { 

struct lvalue_from_python_chain
{
    convertible_function convert;
    lvalue_from_python_chain* next;
};

struct rvalue_from_python_chain
{
    convertible_function convertible;
    constructor_function construct;
    rvalue_from_python_chain* next;
};

struct registration
{
    explicit registration(type_info);
    
    const python::type_info target_type;

    
    lvalue_from_python_chain* lvalue_chain;

    
    rvalue_from_python_chain* rvalue_chain;
    
    
    to_python_function_t to_python;

    
    PyTypeObject* class_object;
};




inline registration::registration(type_info target_type)
    : target_type(target_type)
      , lvalue_chain(0)
      , rvalue_chain(0)
      , to_python(0)
      , class_object(0)
{}

inline bool operator<(registration const& lhs, registration const& rhs)
{
    return lhs.target_type < rhs.target_type;
}

}}} 

#line 10 "/net/cci/rwgk/dist/boost/libs/python/src/converter/arg_to_python_base.cpp"



namespace boost { namespace python { namespace converter { 

namespace
{
    inline PyObject* convert_to_python(void const volatile* source, registration const& converters)
    {
        if (converters.to_python == 0)
        {
            handle<> msg(
                ::PyString_FromFormat(
                    "No to_python (by-value) converter found for C++ type: %s"
                    , converters.target_type.name()));
            
            PyErr_SetObject(PyExc_TypeError, msg.get());

            throw_error_already_set();
        }
        
        return source == 0
            ? incref((&_Py_NoneStruct))
            : converters.to_python(const_cast<void*>(source));
    }
}

namespace detail
{
  arg_to_python_base::arg_to_python_base(
      void const volatile* source, registration const& converters)

      : handle<>(converter::convert_to_python(source, converters))



  {
  }

   void throw_no_class_registered()
  {
      PyErr_SetString(
          PyExc_TypeError
          , const_cast<char*>("class not registered for to_python type"));
      throw_error_already_set();
  }
}

}}}