This is the mail archive of the gcc-bugs@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

gcc internal compiler error when building egcs-20000410


Hi,
  I'm trying to compile egcs-20000410 (I had the same problem with the
previous snapshot) under
Solaris 7 on an Ultra-5/333.  The command I used to configure gcc:

% ../egcs-20000410/configure --prefix=/home/gnu
[...]
% make bootstrap
[...]/home/src/gnu/gcc/current/gcc/cc1plus cinst.ii -quiet -dumpbase
cinst.cc -g -O2 -version -fno-implicit-templates -o cinst.s
GNU C++ version 2.96 20000410 (experimental) (sparc-sun-solaris2.7)
compiled by GNU C version 2.96 20000410 (experimental).
../../../egcs-20000410/libstdc++/std/ldcomplex.h: In function `_FLT abs
(const complex<_FLT> &) [with
../../../egcs-20000410/libstdc++/std/ldcomplex.h: _FLT = f]':
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: Internal compiler
error in `schedule_insns', at
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: haifa-sched.c:7024
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: Please submit a
full bug report.
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: See
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74:
<URL:http://www.gnu.org/software/gcc/bugs.html>
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: for instructions.
*** Error code 1
make: Fatal error: Command failed for target `bigstmp-complx'

I'll append the output of the make command and the cinst.ii.
...dave alden

cd ../libio ; make "SHELL=/bin/sh"  "INSTALL=${rootme}../../../egcs-20000410/libstdc++/../install-sh -c"  "INSTALL_DATA=${rootme}../../../egcs-20000410/libstdc++/../install-sh -c"  "INSTALL_PROGRAM=${rootme}../../../egcs-20000410/libstdc++/../install-sh -c"  "prefix=/home/gnu"  "exec_prefix=/home/gnu"  "tooldir=/home/gnu/sparc-sun-solaris2.7"  "gxx_include_dir=/home/gnu/include/g++-3"  "libsubdir=/home/gnu/lib/gcc-lib/sparc-sun-solaris2.7/2.96"  "gcc_version=2.96"  "gcc_version_trigger=/home/src/gnu/gcc/egcs-20000410/gcc/version.c"  "AR=`if [ -f ${rootme}../../binutils/ar ] ;  then echo ${rootme}../../binutils/ar ;  else echo ar ; fi`"  "AR_FLAGS=rc"  "CC=/home/src/gnu/gcc/current/gcc/xgcc -B/home/src/gnu/gcc/current/gcc/ -B/home/gnu/sparc-sun-solaris2.7/bin/"  "CXX=/home/src/gnu/gcc/current/gcc/g++ -B/home/src/gnu/gcc/current/gcc/ -B/home/gnu/sparc-sun-solaris2.7/bin/"  "CFLAGS=-g -O2"  "CXXFLAGS=-g -O2"  "NM=`if [ -f ${rootme}../../binutils/nm.new ] ;  then echo ${rootme}../../binutils/nm.new ;  else echo nm ; fi`"  "RANLIB=`if [ -f ${rootme}../../binutils/ranlib ] ;  then echo ${rootme}../../binutils/ranlib ;  else echo ranlib ; fi`"  "LIBCFLAGS=-g -O2"  "LIBCXXFLAGS=-g -O2 -fno-implicit-templates"  "LOADLIBES="  "LDFLAGS="  "MAKEINFO=`if [ -f ${rootme}../../texinfo/C/makeinfo ] ;  then echo ${rootme}../../texinfo/C/makeinfo ;  else echo makeinfo ; fi`"  "SHLIB=libstdc++.so.2.10.0"  "SHCURSES="  "RUNTESTFLAGS=" iostream.list
`iostream.list' is up to date.
echo fcomplex
fcomplex
if [ x"no" = xyes ]; then \
  /home/src/gnu/gcc/current/gcc/g++ -B/home/src/gnu/gcc/current/gcc/ -B/home/gnu/sparc-sun-solaris2.7/bin/ -v --save-temps -c -g -O2 -fno-implicit-templates -I../../../egcs-20000410/libstdc++ -I../../../egcs-20000410/libstdc++/stl -I../libio -I../../../egcs-20000410/libstdc++/../libio -nostdinc++   -DF \
    `for N in MAIN ADDCC ADDCF ADDFC SUBCC SUBCF SUBFC MULCC MULCF MULFC DIVCC  DIVCF DIVFC PLUS MINUS EQCC EQCF EQFC NECC NECF NEFC ABS ARG POLAR  CONJ NORM COS COSH EXP LOG POWCC POWCF POWCI POWFC SIN SINH SQRT; do echo " -D${N}"; done` \
    ../../../egcs-20000410/libstdc++/cinst.cc -o pic/fcomplex.o; \
else true ; fi
/home/src/gnu/gcc/current/gcc/g++ -B/home/src/gnu/gcc/current/gcc/ -B/home/gnu/sparc-sun-solaris2.7/bin/ -v --save-temps -c -g -O2 -fno-implicit-templates -I../../../egcs-20000410/libstdc++ -I../../../egcs-20000410/libstdc++/stl -I../libio -I../../../egcs-20000410/libstdc++/../libio -nostdinc++  -DF `for N in MAIN ADDCC ADDCF ADDFC SUBCC SUBCF SUBFC MULCC MULCF MULFC DIVCC  DIVCF DIVFC PLUS MINUS EQCC EQCF EQFC NECC NECF NEFC ABS ARG POLAR  CONJ NORM COS COSH EXP LOG POWCC POWCF POWCI POWFC SIN SINH SQRT; do echo " -D${N}"; done` \
  ../../../egcs-20000410/libstdc++/cinst.cc -o fcomplex.o
Reading specs from /home/src/gnu/gcc/current/gcc/specs
gcc version 2.96 20000410 (experimental)
 /home/src/gnu/gcc/current/gcc/cpp -lang-c++ -nostdinc++ -v -I../../../egcs-20000410/libstdc++ -I../../../egcs-20000410/libstdc++/stl -I../libio -I../../../egcs-20000410/libstdc++/../libio -iprefix /home/src/gnu/gcc/current/gcc/../lib/gcc-lib/sparc-sun-solaris2.7/2.96/ -isystem /home/gnu/sparc-sun-solaris2.7/bin/include -isystem /home/src/gnu/gcc/current/gcc/include -D__GNUC__=2 -D__GNUG__=2 -D__GNUC_MINOR__=96 -D__GNUC_PATCHLEVEL__=0 -D__cplusplus -Dsparc -Dsun -Dunix -D__svr4__ -D__SVR4 -D__sparc__ -D__sun__ -D__unix__ -D__svr4__ -D__SVR4 -D__sparc -D__sun -D__unix -Asystem(unix) -Asystem(svr4) -D__EXCEPTIONS -D__OPTIMIZE__ -g -D__SIZE_TYPE__=unsigned int -D__PTRDIFF_TYPE__=int -D__GCC_NEW_VARARGS__ -Acpu(sparc) -Amachine(sparc) -DF -DMAIN -DADDCC -DADDCF -DADDFC -DSUBCC -DSUBCF -DSUBFC -DMULCC -DMULCF -DMULFC -DDIVCC -DDIVCF -DDIVFC -DPLUS -DMINUS -DEQCC -DEQCF -DEQFC -DNECC -DNECF -DNEFC -DABS -DARG -DPOLAR -DCONJ -DNORM -DCOS -DCOSH -DEXP -DLOG -DPOWCC -DPOWCF -DPOWCI -DPOWFC -DSIN -DSINH -DSQRT ../../../egcs-20000410/libstdc++/cinst.cc cinst.ii
GNU CPP version 2.96 20000410 (experimental) (cpplib)
 (sparc)
ignoring nonexistent directory `/home/gnu/sparc-sun-solaris2.7/bin/include'
ignoring nonexistent directory `/home/src/gnu/gcc/current/lib/gcc-lib/sparc-sun-solaris2.7/2.96/include'
ignoring nonexistent directory `/home/src/gnu/gcc/current/sparc-sun-solaris2.7/include'
ignoring nonexistent directory `/usr/local/include'
ignoring nonexistent directory `/home/gnu/lib/gcc-lib/sparc-sun-solaris2.7/2.96/include'
#include "..." search starts here:
#include <...> search starts here:
 ../../../egcs-20000410/libstdc++
 ../../../egcs-20000410/libstdc++/stl
 ../libio
 ../../../egcs-20000410/libio
 /home/src/gnu/gcc/current/gcc/include
 /home/gnu/sparc-sun-solaris2.7/include
 /usr/include
End of search list.
 /home/src/gnu/gcc/current/gcc/cc1plus cinst.ii -quiet -dumpbase cinst.cc -g -O2 -version -fno-implicit-templates -o cinst.s
GNU C++ version 2.96 20000410 (experimental) (sparc-sun-solaris2.7) compiled by GNU C version 2.96 20000410 (experimental).
../../../egcs-20000410/libstdc++/std/ldcomplex.h: In function `_FLT abs (const complex<_FLT> &) [with
../../../egcs-20000410/libstdc++/std/ldcomplex.h: _FLT = f]':
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: Internal compiler error in `schedule_insns', at
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: haifa-sched.c:7024
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: Please submit a full bug report.
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: See
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: <URL:http://www.gnu.org/software/gcc/bugs.html>
../../../egcs-20000410/libstdc++/std/ldcomplex.h:74: for instructions.
*** Error code 1
make: Fatal error: Command failed for target `bigstmp-complx'
# 1 "../../../egcs-20000410/libstdc++/cinst.cc"
 
 


typedef float f;










#pragma implementation "fcomplex"












# 1 "../../../egcs-20000410/libstdc++/std/complext.cc" 1
 
 

 
 
 
 
 

 
 
 
 

 
 
 

 
 
 
 
 

 
 

# 1 "../../../egcs-20000410/libstdc++/complex" 1
 
 




# 1 "../../../egcs-20000410/libstdc++/std/complext.h" 1
 
 

 
 
 
 

 
 
 
 

 
 
 

 
 
 
 
 

 
 





#pragma interface 


# 1 "../../../egcs-20000410/libstdc++/cmath" 1
 
 



# 1 "../libio/_G_config.h" 1
  









typedef          int   _G_int8_t __attribute__((__mode__(__QI__)));
typedef unsigned int  _G_uint8_t __attribute__((__mode__(__QI__)));
typedef          int  _G_int16_t __attribute__((__mode__(__HI__)));
typedef unsigned int _G_uint16_t __attribute__((__mode__(__HI__)));
typedef          int  _G_int32_t __attribute__((__mode__(__SI__)));
typedef unsigned int _G_uint32_t __attribute__((__mode__(__SI__)));
typedef          int  _G_int64_t __attribute__((__mode__(__DI__)));
typedef unsigned int _G_uint64_t __attribute__((__mode__(__DI__)));

__extension__ typedef long long _G_llong;
__extension__ typedef unsigned long long _G_ullong;








typedef long _G_clock_t;
typedef unsigned long _G_dev_t;
typedef long _G_fpos_t;
typedef long _G_gid_t;
typedef unsigned long _G_ino_t;
typedef unsigned long _G_mode_t;
typedef unsigned long _G_nlink_t;
typedef long _G_off_t;
typedef long _G_pid_t;



typedef int _G_ptrdiff_t;
typedef int   _G_sigset_t;



typedef unsigned int _G_size_t;
typedef long _G_time_t;
typedef long _G_uid_t;
typedef long int _G_wchar_t;















typedef int _G_ssize_t;
typedef unsigned int _G_wint_t;
typedef __builtin_va_list _G_va_list;

















# 1 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 1 3 4
 
# 19 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4

 






 








 



# 49 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4


 


 





 



# 91 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4

 





 


















 





 

 


# 161 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4

 

 


# 220 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4


 




 


# 304 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4


# 316 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4

 

 

# 349 "/home/src/gnu/gcc/current/gcc/include/stddef.h" 3 4



 





















# 86 "../libio/_G_config.h" 2


# 6 "../../../egcs-20000410/libstdc++/cmath" 2

# 1 "/home/src/gnu/gcc/current/gcc/include/math.h" 1 3 4




 # 1 "/usr/include/math.h" 1 3 4
 







extern "C" {


#pragma ident "@(#)math.h	2.7	98/01/27" 











 


typedef union _h_val {
  	unsigned long _i[sizeof(double) / sizeof(unsigned long)];
	double _d;
} _h_val;


extern const _h_val __huge_val;








 
















extern int signgam;




 


enum version {libm_ieee = -1, c_issue_4, ansi_1, strict_ansi};


extern const enum version _lib_version;




struct __math_exception {
	int type;
	char *name;
	double arg1;
	double arg2;
	double retval;
};




























 


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

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

extern double exp (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 sqrt (double);

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



 


extern double erf (double);
extern double erfc (double);
extern double gamma (double);
extern double hypot (double, double);
extern int isnan (double);
extern double j0 (double);
extern double j1 (double);
extern double jn (int, double);
extern double lgamma (double);
extern double y0 (double);
extern double y1 (double);
extern double yn (int, double);




 


extern double acosh (double);
extern double asinh (double);
extern double atanh (double);
extern double cbrt (double);
extern double logb (double);
extern double nextafter (double, double);
extern double remainder (double, double);
extern double scalb (double, double);

 


extern double expm1 (double);
extern int ilogb (double);
extern double log1p (double);
extern double rint (double);



 


extern int matherr (struct __math_exception *);

 


extern double significand (double);

 


extern double copysign (double, double);
extern double scalbn (double, int);

 








 


extern float modff (float, float *);

# 1 "/usr/include/floatingpoint.h" 1 3 4
 
 

 
 
 





extern "C" {


#pragma ident "@(#)floatingpoint.h	2.4 94/06/09" 

 




 
# 31 "/usr/include/floatingpoint.h" 3 4


# 1 "/usr/include/stdio.h" 1 3 4
 
 

 
 
 

 




 






#pragma ident "@(#)stdio.h	1.69	98/07/13 SMI" 

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
 




 
 
 




#pragma ident "@(#)feature_tests.h	1.17	97/12/04 SMI" 

# 1 "/usr/include/sys/isa_defs.h" 1 3 4
 







#pragma ident "@(#)isa_defs.h	1.15	97/11/22 SMI" 

 
# 140 "/usr/include/sys/isa_defs.h" 3 4


extern "C" {



 







# 212 "/usr/include/sys/isa_defs.h" 3 4

 






 






 









 
















 






 





 







 








 




# 310 "/usr/include/sys/isa_defs.h" 3 4

 











}



# 15 "/usr/include/sys/feature_tests.h" 2 3 4



extern "C" {


 
# 30 "/usr/include/sys/feature_tests.h" 3 4




 
# 63 "/usr/include/sys/feature_tests.h" 3 4












 
# 87 "/usr/include/sys/feature_tests.h" 3 4
















 
# 119 "/usr/include/sys/feature_tests.h" 3 4




 
# 138 "/usr/include/sys/feature_tests.h" 3 4








 
# 162 "/usr/include/sys/feature_tests.h" 3 4













}



# 22 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/sys/va_list.h" 1 3 4
 







#pragma ident "@(#)va_list.h	1.11	97/11/22 SMI" 

 
# 20 "/usr/include/sys/va_list.h" 3 4


extern "C" {



typedef void *__va_list;





}



# 23 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/stdio_tag.h" 1 3 4
 







#pragma ident "@(#)stdio_tag.h	1.3	98/04/20 SMI" 


extern "C" {








typedef struct FILE __FILE;



}



# 24 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/stdio_impl.h" 1 3 4
 







#pragma ident "@(#)stdio_impl.h	1.7	98/04/17 SMI" 




extern "C" {







typedef int	ssize_t;		 




# 37 "/usr/include/stdio_impl.h" 3 4

struct FILE	 
{




	ssize_t		_cnt;	 
	unsigned char	*_ptr;	 

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




}



# 25 "/usr/include/stdio.h" 2 3 4


 








extern "C" {




typedef	__FILE FILE;







typedef unsigned int	size_t;		 




 





typedef	long long	__longlong_t;













typedef long		off_t;







typedef __longlong_t	off64_t;






typedef long		fpos_t;







typedef __longlong_t	fpos64_t;













 










 
# 135 "/usr/include/stdio.h" 3 4






















































extern FILE	__iob[20];











extern unsigned char	 _sibuf[], _sobuf[];


 

# 228 "/usr/include/stdio.h" 3 4


extern unsigned char	*_bufendtab[];
extern FILE		*_lastbuf;


 

# 258 "/usr/include/stdio.h" 3 4



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 void setbuffer(FILE *, char *, size_t);
extern int setlinebuf(FILE *);

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	snprintf(char *, size_t, 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	vsnprintf(char *, size_t, const char *, __va_list);

extern int	vsprintf(char *, const char *, __va_list);
extern int	fgetc(FILE *);
extern char	*fgets(char *, int, FILE *);
extern int	fputc(int, FILE *);
extern int	fputs(const char *, FILE *);
extern int	getc(FILE *);
extern int	getchar(void);
extern char	*gets(char *);
extern int	putc(int, FILE *);
extern int	putchar(int);
extern int	puts(const char *);
extern int	ungetc(int, FILE *);
extern size_t	fread(void *, size_t, size_t, FILE *);
extern size_t	fwrite(const void *, size_t, size_t, FILE *);
extern int	fgetpos(FILE *, fpos_t *);
extern int	fseek(FILE *, long, int);
extern int	fsetpos(FILE *, const fpos_t *);
extern long	ftell(FILE *);
extern void	rewind(FILE *);
extern void	clearerr(FILE *);
extern int	feof(FILE *);
extern int	ferror(FILE *);
extern void	perror(const char *);


extern int	__filbuf(FILE *);
extern int	__flsbuf(int, FILE *);


 





extern FILE	*fdopen(int, const char *);
extern char	*ctermid(char *);
extern int	fileno(FILE *);



 



# 359 "/usr/include/stdio.h" 3 4

 




extern FILE	*popen(const char *, const char *);
extern char	*cuserid(char *);
extern char	*tempnam(const char *, const char *);
extern int	getopt(int, char *const *, const char *);

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

extern char	*optarg;
extern int	optind, opterr, optopt;
extern int	getw(FILE *);
extern int	putw(int, FILE *);
extern int	pclose(FILE *);



 



extern int	fseeko(FILE *, off_t, int);
extern off_t	ftello(FILE *);


 





extern FILE	*fopen64(const char *, const char *);
extern FILE	*freopen64(const char *, const char *, FILE *);
extern FILE	*tmpfile64(void);
extern int	fgetpos64(FILE *, fpos64_t *);
extern int	fsetpos64(FILE *, const fpos64_t *);
extern int	fseeko64(FILE *, off64_t, int);
extern off64_t	ftello64(FILE *);



# 516 "/usr/include/stdio.h" 3 4





























# 568 "/usr/include/stdio.h" 3 4




}



# 33 "/usr/include/floatingpoint.h" 2 3 4


# 1 "/usr/include/sys/ieeefp.h" 1 3 4
 






#pragma ident "@(#)ieeefp.h	2.7 94/11/09" 


extern "C" {


 



enum fp_direction_type {	 
	fp_nearest	= 0,
	fp_tozero	= 1,
	fp_positive	= 2,
	fp_negative	= 3
};

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

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

enum fp_trap_enable_type {	 
	fp_trap_inexact	= 0,
	fp_trap_division	= 1,
	fp_trap_underflow	= 2,
	fp_trap_overflow	= 3,
	fp_trap_invalid	= 4
};



# 82 "/usr/include/sys/ieeefp.h" 3 4


# 123 "/usr/include/sys/ieeefp.h" 3 4

enum fp_class_type {		 
	fp_zero		= 0,
	fp_subnormal	= 1,
	fp_normal	= 2,
	fp_infinity   	= 3,
	fp_quiet	= 4,
	fp_signaling	= 5
};


}



# 35 "/usr/include/floatingpoint.h" 2 3 4










typedef int sigfpe_code_type;	 

typedef void (*sigfpe_handler_type)();	 





extern sigfpe_handler_type sigfpe (sigfpe_code_type, sigfpe_handler_type);

 


typedef float single;			



typedef unsigned extended[3];


typedef long double quadruple;	 

typedef unsigned fp_exception_field_type;
				 



 




typedef char decimal_string[512];	
				 

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


	int	more;		 


	int 	ndigits;	 


} decimal_record;

enum decimal_form {
	fixed_form,		 


	floating_form		 

};

typedef struct {
	enum fp_direction_type rd;	
				 
	enum decimal_form df;	 

	int ndigits;		 
} decimal_mode;

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

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

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

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

				enum decimal_string_form *, char **,
# 150 "/usr/include/floatingpoint.h" 3 4
				int (*)(void), int *, int (*)(int));
extern void file_to_decimal (char **, int, int, decimal_record *,

				enum decimal_string_form *, char **,
# 153 "/usr/include/floatingpoint.h" 3 4
				FILE *, int *);

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

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

 



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


}



# 213 "/usr/include/math.h" 2 3 4





}



# 5 "/home/src/gnu/gcc/current/gcc/include/math.h" 2 3 4






# 7 "../../../egcs-20000410/libstdc++/cmath" 2



#pragma interface "cmath" 


extern "C++" {

# 39 "../../../egcs-20000410/libstdc++/cmath"

inline float  abs (float  x) { return fabs (x); }

inline double abs (double x) { return fabs (x); }



# 72 "../../../egcs-20000410/libstdc++/cmath"
inline long double abs (long double x) { return fabs (x); }

}  


# 34 "../../../egcs-20000410/libstdc++/std/complext.h" 2






class istream;
class ostream;

extern "C++" {
template <class _FLT> class complex;
template <class _FLT> complex<_FLT>&
  __doapl (complex<_FLT>* ths, const complex<_FLT>& r);
template <class _FLT> complex<_FLT>&
  __doami (complex<_FLT>* ths, const complex<_FLT>& r);
template <class _FLT> complex<_FLT>&
  __doaml (complex<_FLT>* ths, const complex<_FLT>& r);
template <class _FLT> complex<_FLT>&
  __doadv (complex<_FLT>* ths, const complex<_FLT>& r);

template <class _FLT>
class complex
{
public:
  complex (_FLT r = 0, _FLT i = 0): re (r), im (i) { }
  complex& operator += (const complex&);
  complex& operator -= (const complex&);
  complex& operator *= (const complex&);
  complex& operator /= (const complex&);
  _FLT real () const { return re; }
  _FLT imag () const { return im; }
private:
  _FLT re, im;

  friend complex& __doapl<> (complex *, const complex&);
  friend complex& __doami<> (complex *, const complex&);
  friend complex& __doaml<> (complex *, const complex&);
  friend complex& __doadv<> (complex *, const complex&);
};

 
class complex<float>;
class complex<double>;
class complex<long double>;

template <class _FLT>
inline complex<_FLT>&
__doapl (complex<_FLT>* ths, const complex<_FLT>& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}
template <class _FLT>
inline complex<_FLT>&
complex<_FLT>::operator += (const complex<_FLT>& r)
{
  return __doapl (this, r);
}

template <class _FLT>
inline complex<_FLT>&
__doami (complex<_FLT>* ths, const complex<_FLT>& r)
{
  ths->re -= r.re;
  ths->im -= r.im;
  return *ths;
}
template <class _FLT>
inline complex<_FLT>&
complex<_FLT>::operator -= (const complex<_FLT>& r)
{
  return __doami (this, r);
}

template <class _FLT>
inline complex<_FLT>&
__doaml (complex<_FLT>* ths, const complex<_FLT>& r)
{
  _FLT f = ths->re * r.re - ths->im * r.im;
  ths->im = ths->re * r.im + ths->im * r.re;
  ths->re = f;
  return *ths;
}
template <class _FLT>
inline complex<_FLT>&
complex<_FLT>::operator *= (const complex<_FLT>& r)
{
  return __doaml (this, r);
}

template <class _FLT>
inline complex<_FLT>&
complex<_FLT>::operator /= (const complex<_FLT>& r)
{
  return __doadv (this, r);
}

template <class _FLT> inline _FLT
imag (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline _FLT
imag (const complex<_FLT>& x)
{
  return x.imag ();
}

template <class _FLT> inline _FLT
real (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline _FLT
real (const complex<_FLT>& x)
{
  return x.real ();
}

template <class _FLT> inline complex<_FLT>
operator + (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator + (const complex<_FLT>& x, const complex<_FLT>& y)
{
  return complex<_FLT> (real (x) + real (y), imag (x) + imag (y));
}

template <class _FLT> inline complex<_FLT>
operator + (const complex<_FLT>& x, _FLT y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator + (const complex<_FLT>& x, _FLT y)
{
  return complex<_FLT> (real (x) + y, imag (x));
}

template <class _FLT> inline complex<_FLT>
operator + (_FLT x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator + (_FLT x, const complex<_FLT>& y)
{
  return complex<_FLT> (x + real (y), imag (y));
}

template <class _FLT> inline complex<_FLT>
operator - (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator - (const complex<_FLT>& x, const complex<_FLT>& y)
{
  return complex<_FLT> (real (x) - real (y), imag (x) - imag (y));
}

template <class _FLT> inline complex<_FLT>
operator - (const complex<_FLT>& x, _FLT y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator - (const complex<_FLT>& x, _FLT y)
{
  return complex<_FLT> (real (x) - y, imag (x));
}

template <class _FLT> inline complex<_FLT>
operator - (_FLT x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator - (_FLT x, const complex<_FLT>& y)
{
  return complex<_FLT> (x - real (y), - imag (y));
}

template <class _FLT> inline complex<_FLT>
operator * (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator * (const complex<_FLT>& x, const complex<_FLT>& y)
{
  return complex<_FLT> (real (x) * real (y) - imag (x) * imag (y),
			   real (x) * imag (y) + imag (x) * real (y));
}

template <class _FLT> inline complex<_FLT>
operator * (const complex<_FLT>& x, _FLT y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator * (const complex<_FLT>& x, _FLT y)
{
  return complex<_FLT> (real (x) * y, imag (x) * y);
}

template <class _FLT> inline complex<_FLT>
operator * (_FLT x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator * (_FLT x, const complex<_FLT>& y)
{
  return complex<_FLT> (x * real (y), x * imag (y));
}

template <class _FLT> complex<_FLT>
operator / (const complex<_FLT>& x, _FLT y) __attribute__ ((const));

template <class _FLT> complex<_FLT>
operator / (const complex<_FLT>& x, _FLT y)
{
  return complex<_FLT> (real (x) / y, imag (x) / y);
}

template <class _FLT> inline complex<_FLT>
operator + (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator + (const complex<_FLT>& x)
{
  return x;
}

template <class _FLT> inline complex<_FLT>
operator - (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
operator - (const complex<_FLT>& x)
{
  return complex<_FLT> (-real (x), -imag (x));
}

template <class _FLT> inline bool
operator == (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline bool
operator == (const complex<_FLT>& x, const complex<_FLT>& y)
{
  return real (x) == real (y) && imag (x) == imag (y);
}

template <class _FLT> inline bool
operator == (const complex<_FLT>& x, _FLT y) __attribute__ ((const));

template <class _FLT> inline bool
operator == (const complex<_FLT>& x, _FLT y)
{
  return real (x) == y && imag (x) == 0;
}

template <class _FLT> inline bool
operator == (_FLT x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline bool
operator == (_FLT x, const complex<_FLT>& y)
{
  return x == real (y) && imag (y) == 0;
}

template <class _FLT> inline bool
operator != (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline bool
operator != (const complex<_FLT>& x, const complex<_FLT>& y)
{
  return real (x) != real (y) || imag (x) != imag (y);
}

template <class _FLT> inline bool
operator != (const complex<_FLT>& x, _FLT y) __attribute__ ((const));

template <class _FLT> inline bool
operator != (const complex<_FLT>& x, _FLT y)
{
  return real (x) != y || imag (x) != 0;
}

template <class _FLT> inline bool
operator != (_FLT x, const complex<_FLT>& y) __attribute__ ((const));

template <class _FLT> inline bool
operator != (_FLT x, const complex<_FLT>& y)
{
  return x != real (y) || imag (y) != 0;
}

 
extern "C" double hypot (double, double) __attribute__ ((const));

template <class _FLT> inline _FLT
abs (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline _FLT
abs (const complex<_FLT>& x)
{
  return hypot (real (x), imag (x));
}

template <class _FLT> inline _FLT
arg (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline _FLT
arg (const complex<_FLT>& x)
{
  return atan2 (imag (x), real (x));
}

template <class _FLT> inline complex<_FLT>
polar (_FLT r, _FLT t) __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
polar (_FLT r, _FLT t)
{
  return complex<_FLT> (r * cos (t), r * sin (t));
}

template <class _FLT> inline complex<_FLT>
conj (const complex<_FLT>& x)  __attribute__ ((const));

template <class _FLT> inline complex<_FLT>
conj (const complex<_FLT>& x) 
{
  return complex<_FLT> (real (x), -imag (x));
}

template <class _FLT> inline _FLT
norm (const complex<_FLT>& x) __attribute__ ((const));

template <class _FLT> inline _FLT
norm (const complex<_FLT>& x)
{
  return real (x) * real (x) + imag (x) * imag (x);
}

 

template <class _FLT> complex<_FLT>
  operator / (const complex<_FLT>&, const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  operator / (_FLT, const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  cos (const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  cosh (const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  exp (const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  log (const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  pow (const complex<_FLT>&, const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  pow (const complex<_FLT>&, _FLT) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  pow (const complex<_FLT>&, int) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  pow (_FLT, const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  sin (const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  sinh (const complex<_FLT>&) __attribute__ ((const));
template <class _FLT> complex<_FLT>
  sqrt (const complex<_FLT>&) __attribute__ ((const));

template <class _FLT> istream& operator >> (istream&, complex<_FLT>&);
template <class _FLT> ostream& operator << (ostream&, const complex<_FLT>&);
}  

 

# 1 "../../../egcs-20000410/libstdc++/std/fcomplex.h" 1
 
 

 
 
 
 
 

 
 
 
 

 
 
 

 
 
 
 
 

 
 





#pragma interface "fcomplex" 


extern "C++" {
class complex<float>
{
public:
  complex (float r = 0, float i = 0): re (r), im (i) { }
  explicit complex (const complex<double>& r);
  explicit complex (const complex<long double>& r);

  complex& operator+= (const complex& r) { return __doapl (this, r); }
  complex& operator-= (const complex& r) { return __doami (this, r); }
  complex& operator*= (const complex& r) { return __doaml (this, r); }
  complex& operator/= (const complex& r) { return __doadv (this, r); }

  float real () const { return re; }
  float imag () const { return im; }
private:
  float re, im;

  friend complex& __doapl<> (complex *, const complex&);
  friend complex& __doami<> (complex *, const complex&);
  friend complex& __doaml<> (complex *, const complex&);
  friend complex& __doadv<> (complex *, const complex&);


  friend inline complex operator + (const complex& x, float y)
    { return operator+<> (x, y); }
  friend inline complex operator + (float x, const complex& y)
    { return operator+<> (x, y); }
  friend inline complex operator - (const complex& x, float y)
    { return operator-<> (x, y); }
  friend inline complex operator - (float x, const complex& y)
    { return operator-<> (x, y); }
  friend inline complex operator * (const complex& x, float y)
    { return operator*<> (x, y); }
  friend inline complex operator * (float x, const complex& y)
    { return operator*<> (x, y); }
  friend inline complex operator / (const complex& x, float y)
    { return operator/<> (x, y); }
  friend inline complex operator / (float x, const complex& y)
    { return operator/<> (x, y); }
  friend inline bool operator == (const complex& x, float y)
    { return operator==<> (x, y); }
  friend inline bool operator == (float x, const complex& y)
    { return operator==<> (x, y); }
  friend inline bool operator != (const complex& x, float y)
    { return operator!=<> (x, y); }
  friend inline bool operator != (float x, const complex& y)
    { return operator!=<> (x, y); }

};
}  


# 396 "../../../egcs-20000410/libstdc++/std/complext.h" 2

# 1 "../../../egcs-20000410/libstdc++/std/dcomplex.h" 1
 
 

 
 
 
 
 

 
 
 
 

 
 
 

 
 
 
 
 

 
 





#pragma interface "dcomplex" 


extern "C++" {
class complex<double>
{
public:
  complex (double r = 0, double i = 0): re (r), im (i) { }
  complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
  explicit complex (const complex<long double>& r);

  complex& operator+= (const complex& r) { return __doapl (this, r); }
  complex& operator-= (const complex& r) { return __doami (this, r); }
  complex& operator*= (const complex& r) { return __doaml (this, r); }
  complex& operator/= (const complex& r) { return __doadv (this, r); }

  double real () const { return re; }
  double imag () const { return im; }
private:
  double re, im;

  friend complex& __doapl<> (complex *, const complex&);
  friend complex& __doami<> (complex *, const complex&);
  friend complex& __doaml<> (complex *, const complex&);
  friend complex& __doadv<> (complex *, const complex&);


  friend inline complex operator + (const complex& x, double y)
    { return operator+<> (x, y); }
  friend inline complex operator + (double x, const complex& y)
    { return operator+<> (x, y); }
  friend inline complex operator - (const complex& x, double y)
    { return operator-<> (x, y); }
  friend inline complex operator - (double x, const complex& y)
    { return operator-<> (x, y); }
  friend inline complex operator * (const complex& x, double y)
    { return operator*<> (x, y); }
  friend inline complex operator * (double x, const complex& y)
    { return operator*<> (x, y); }
  friend inline complex operator / (const complex& x, double y)
    { return operator/<> (x, y); }
  friend inline complex operator / (double x, const complex& y)
    { return operator/<> (x, y); }
  friend inline bool operator == (const complex& x, double y)
    { return operator==<> (x, y); }
  friend inline bool operator == (double x, const complex& y)
    { return operator==<> (x, y); }
  friend inline bool operator != (const complex& x, double y)
    { return operator!=<> (x, y); }
  friend inline bool operator != (double x, const complex& y)
    { return operator!=<> (x, y); }

};

inline complex<float>::complex (const complex<double>& r)
: re (r.real ()), im (r.imag ())
{ }
}  


# 397 "../../../egcs-20000410/libstdc++/std/complext.h" 2

# 1 "../../../egcs-20000410/libstdc++/std/ldcomplex.h" 1
 
 

 
 
 
 
 

 
 
 
 

 
 
 

 
 
 
 
 

 
 





#pragma interface "ldcomplex" 


extern "C++" {
class complex<long double>
{
public:
  complex (long double r = 0, long double i = 0): re (r), im (i) { }
  complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
  complex (const complex<double>& r): re (r.real ()), im (r.imag ()) { }

  complex& operator+= (const complex& r) { return __doapl (this, r); }
  complex& operator-= (const complex& r) { return __doami (this, r); }
  complex& operator*= (const complex& r) { return __doaml (this, r); }
  complex& operator/= (const complex& r) { return __doadv (this, r); }

  long double real () const { return re; }
  long double imag () const { return im; }
private:
  long double re, im;

  friend complex& __doapl<> (complex *, const complex&);
  friend complex& __doami<> (complex *, const complex&);
  friend complex& __doaml<> (complex *, const complex&);
  friend complex& __doadv<> (complex *, const complex&);


  friend inline complex operator + (const complex& x, long double y)
    { return operator+<> (x, y); }
  friend inline complex operator + (long double x, const complex& y)
    { return operator+<> (x, y); }
  friend inline complex operator - (const complex& x, long double y)
    { return operator-<> (x, y); }
  friend inline complex operator - (long double x, const complex& y)
    { return operator-<> (x, y); }
  friend inline complex operator * (const complex& x, long double y)
    { return operator*<> (x, y); }
  friend inline complex operator * (long double x, const complex& y)
    { return operator*<> (x, y); }
  friend inline complex operator / (const complex& x, long double y)
    { return operator/<> (x, y); }
  friend inline complex operator / (long double x, const complex& y)
    { return operator/<> (x, y); }
  friend inline bool operator == (const complex& x, long double y)
    { return operator==<> (x, y); }
  friend inline bool operator == (long double x, const complex& y)
    { return operator==<> (x, y); }
  friend inline bool operator != (const complex& x, long double y)
    { return operator!=<> (x, y); }
  friend inline bool operator != (long double x, const complex& y)
    { return operator!=<> (x, y); }

};

inline complex<float>::complex (const complex<long double>& r)
: re (r.real ()), im (r.imag ())
{ }

inline complex<double>::complex (const complex<long double>& r)
: re (r.real ()), im (r.imag ())
{ }
}  


# 398 "../../../egcs-20000410/libstdc++/std/complext.h" 2



# 7 "../../../egcs-20000410/libstdc++/complex" 2


extern "C++" {


 
typedef complex<float> float_complex;
typedef complex<double> double_complex;
typedef complex<long double> long_double_complex;
}


# 28 "../../../egcs-20000410/libstdc++/std/complext.cc" 2


extern "C++" {
template <class FLOAT> complex<FLOAT>
cos (const complex<FLOAT>& x)
{
  return complex<FLOAT> (cos (real (x)) * cosh (imag (x)),
			   - sin (real (x)) * sinh (imag (x)));
}

template <class FLOAT> complex<FLOAT>
cosh (const complex<FLOAT>& x)
{
  return complex<FLOAT> (cosh (real (x)) * cos (imag (x)),
			   sinh (real (x)) * sin (imag (x)));
}

template <class FLOAT> complex<FLOAT>
exp (const complex<FLOAT>& x)
{
  return polar (FLOAT (exp (real (x))), imag (x));
}

template <class FLOAT> complex<FLOAT>
log (const complex<FLOAT>& x)
{
  return complex<FLOAT> (log (abs (x)), arg (x));
}

template <class FLOAT> complex<FLOAT>
pow (const complex<FLOAT>& x, const complex<FLOAT>& y)
{
  FLOAT logr = log (abs (x));
  FLOAT t = arg (x);

  return polar (FLOAT (exp (logr * real (y) - imag (y) * t)),
		FLOAT (imag (y) * logr + real (y) * t));
}

template <class FLOAT> complex<FLOAT>
pow (const complex<FLOAT>& x, FLOAT y)
{
  return exp (FLOAT (y) * log (x));
}

template <class FLOAT> complex<FLOAT>
pow (FLOAT x, const complex<FLOAT>& y)
{
  return exp (y * FLOAT (log (x)));
}

template <class FLOAT> complex<FLOAT>
sin (const complex<FLOAT>& x)
{
  return complex<FLOAT> (sin (real (x)) * cosh (imag (x)),
			   cos (real (x)) * sinh (imag (x)));
}

template <class FLOAT> complex<FLOAT>
sinh (const complex<FLOAT>& x)
{
  return complex<FLOAT> (sinh (real (x)) * cos (imag (x)),
			   cosh (real (x)) * sin (imag (x)));
}

# 1 "../../../egcs-20000410/libio/iostream.h" 1
 
# 24 "../../../egcs-20000410/libio/iostream.h"



#pragma interface 



# 1 "../../../egcs-20000410/libio/streambuf.h" 1
 
# 24 "../../../egcs-20000410/libio/streambuf.h"




#pragma interface 


   



extern "C" {
# 1 "../../../egcs-20000410/libio/libio.h" 1
 
# 26 "../../../egcs-20000410/libio/libio.h"






















# 56 "../../../egcs-20000410/libio/libio.h"


# 68 "../../../egcs-20000410/libio/libio.h"









 
















# 105 "../../../egcs-20000410/libio/libio.h"










 
























 



















struct _IO_jump_t;  struct _IO_FILE;

 

# 175 "../../../egcs-20000410/libio/libio.h"








    typedef void _IO_lock_t;





 

struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;
   

   
  int _pos;

# 208 "../../../egcs-20000410/libio/libio.h"
};

struct _IO_FILE {
  int _flags;		 


   
   
  char* _IO_read_ptr;	 
  char* _IO_read_end;	 
  char* _IO_read_base;	 
  char* _IO_write_base;	 
  char* _IO_write_ptr;	 
  char* _IO_write_end;	 
  char* _IO_buf_base;	 
  char* _IO_buf_end;	 
   
  char *_IO_save_base;  
  char *_IO_backup_base;   
  char *_IO_save_end;  

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _blksize;



  _G_off_t _offset;



   
  unsigned short _cur_column;
  char _unused;
  char _shortbuf[1];

   








};











struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_stdin_, _IO_stdout_, _IO_stderr_;





 
typedef struct
{
  _G_ssize_t (*read) (struct _IO_FILE *, void *, _G_ssize_t);
  _G_ssize_t (*write) (struct _IO_FILE *, const void *, _G_ssize_t);
  _G_off_t (*seek) (struct _IO_FILE *, _G_off_t, int);
  int (*close) (struct _IO_FILE *);
} _IO_cookie_io_functions_t;

 
struct _IO_cookie_file
{
  struct _IO_FILE file;
  const void *vtable;
  void *cookie;
  _IO_cookie_io_functions_t io_functions;
};



extern "C" {


extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);

















extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp);
extern int _IO_ferror (_IO_FILE *__fp);

extern int _IO_peekc_locked (_IO_FILE *__fp);

 



extern void _IO_flockfile (_IO_FILE *);
extern void _IO_funlockfile (_IO_FILE *);
extern int _IO_ftrylockfile (_IO_FILE *);













extern int _IO_vfscanf (_IO_FILE *, const char *, _G_va_list, int *);
extern int _IO_vfprintf (_IO_FILE *, const char *, _G_va_list);
extern _G_ssize_t _IO_padn (_IO_FILE *, int, _G_ssize_t);
extern _G_size_t _IO_sgetn (_IO_FILE *, void *, _G_size_t);





extern _G_off_t _IO_seekoff (_IO_FILE *, _G_off_t, int, int);
extern _G_off_t _IO_seekpos (_IO_FILE *, _G_off_t, int);


extern void _IO_free_backup_area (_IO_FILE *);


}



# 36 "../../../egcs-20000410/libio/streambuf.h" 2

}
 


























extern "C++" {
class istream;  
class ostream; class streambuf;

 







typedef _G_off_t streamoff;
typedef _G_off_t streampos;

typedef _G_ssize_t streamsize;

typedef unsigned long __fmtflags;
typedef unsigned char __iostate;

struct _ios_fields
{  
    streambuf *_strbuf;
    ostream* _tie;
    int _width;
    __fmtflags _flags;
    short _fill;
    __iostate _state;
    __iostate _exceptions;
    int _precision;

    void *_arrays;  
};
















# 125 "../../../egcs-20000410/libio/streambuf.h"

class ios : public _ios_fields {
  ios& operator=(ios&);   
  ios (const ios&);  
  public:
    typedef __fmtflags fmtflags;
    typedef int iostate;
    typedef int openmode;
    typedef _G_ssize_t streamsize;
    enum io_state {
	goodbit = 0,
	eofbit = 1,
	failbit = 2,
	badbit = 4 };
    enum open_mode {
	in = 1,
	out = 2,
	ate = 4,
	app = 8,
	trunc = 16,
	nocreate = 32,
	noreplace = 64,
	bin = 128,  
	binary = 128 };
    enum seek_dir { beg, cur, end};
    typedef enum seek_dir seekdir;
     
    enum { skipws=01,
	   left=02, right=04, internal=010,
	   dec=020, oct=040, hex=0100,
	   showbase=0200, showpoint=0400,
	   uppercase=01000, showpos=02000,
	   scientific=04000, fixed=010000,
	   unitbuf=020000, stdio=040000



	   };
    enum {  
	basefield=dec+oct+hex,
	floatfield = scientific+fixed,
	adjustfield = left+right+internal
    };


# 178 "../../../egcs-20000410/libio/streambuf.h"

    ostream* tie() const { return _tie; }
    ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }

     
    short fill() const { return _fill; }
    short fill(short newf)
	{short oldf = _fill; _fill = newf; return oldf;}
    fmtflags flags() const { return _flags; }
    fmtflags flags(fmtflags new_val) {
	fmtflags old_val = _flags; _flags = new_val; return old_val; }
    int precision() const { return _precision; }
    int precision(int newp) {
	unsigned short oldp = _precision; _precision = (unsigned short)newp;
	return oldp; }
    fmtflags setf(fmtflags val) {
	fmtflags oldbits = _flags;
	_flags |= val; return oldbits; }
    fmtflags setf(fmtflags val, fmtflags mask) {
	fmtflags oldbits = _flags;
	_flags = (_flags & ~mask) | (val & mask); return oldbits; }
    fmtflags unsetf(fmtflags mask) {
	fmtflags oldbits = _flags;
	_flags &= ~mask; return oldbits; }
    int width() const { return _width; }
    int width(int val) { int save = _width; _width = val; return save; }




    void _throw_failure() const { }

    void clear(iostate state = 0) {
	_state = _strbuf ? state : state|badbit;
	if (_state & _exceptions) _throw_failure(); }
    void set(iostate flag) { _state |= flag;
	if (_state & _exceptions) _throw_failure(); }
    void setstate(iostate flag) { _state |= flag;  
	if (_state & _exceptions) _throw_failure(); }
    int good() const { return _state == 0; }
    int eof() const { return _state & ios::eofbit; }
    int fail() const { return _state & (ios::badbit|ios::failbit); }
    int bad() const { return _state & ios::badbit; }
    iostate rdstate() const { return _state; }
    operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
    int operator!() const { return fail(); }
    iostate exceptions() const { return _exceptions; }
    void exceptions(iostate enable) {
	_exceptions = enable;
	if (_state & _exceptions) _throw_failure(); }

    streambuf* rdbuf() const { return _strbuf; }
    streambuf* rdbuf(streambuf *_s) {
      streambuf *_old = _strbuf; _strbuf = _s; clear (); return _old; }

    static int sync_with_stdio(int on);
    static void sync_with_stdio() { sync_with_stdio(1); }
    static fmtflags bitalloc();
    static int xalloc();
    void*& pword(int);
    void* pword(int) const;
    long& iword(int);
    long iword(int) const;









     
    class Init {
    public:
      Init () { }
    };

  protected:
    inline ios(streambuf* sb = 0, ostream* tie_to = 0);
    inline virtual ~ios();
    inline void init(streambuf* sb, ostream* tie = 0);
};




typedef ios::seek_dir _seek_dir;


 
 
 
 
 

 
 
class streammarker : private _IO_marker {
    friend class streambuf;
    void set_offset(int offset) { _pos = offset; }
  public:
    streammarker(streambuf *sb);
    ~streammarker();
    int saving() { return  1; }
    int delta(streammarker&);
    int delta();
};

struct streambuf : public _IO_FILE {  
    friend class ios;
    friend class istream;
    friend class ostream;
    friend class streammarker;
    const void *&_vtable() { return *(const void**)((_IO_FILE*)this + 1); }
  protected:
    static streambuf* _list_all;  
    _IO_FILE*& xchain() { return _chain; }
    void _un_link();
    void _link_in();
    char* gptr() const
      { return _flags & 0x100 ? _IO_save_base : _IO_read_ptr; }
    char* pptr() const { return _IO_write_ptr; }
    char* egptr() const
      { return _flags & 0x100 ? _IO_save_end : _IO_read_end; }
    char* epptr() const { return _IO_write_end; }
    char* pbase() const { return _IO_write_base; }
    char* eback() const
      { return _flags & 0x100 ? _IO_save_base : _IO_read_base;}
    char* base() const { return _IO_buf_base; }
    char* ebuf() const { return _IO_buf_end; }
    int blen() const { return _IO_buf_end - _IO_buf_base; }
    void xput_char(char c) { *_IO_write_ptr++ = c; }
    int xflags() { return _flags; }
    int xflags(int f) {int fl = _flags; _flags = f; return fl;}
    void xsetflags(int f) { _flags |= f; }
    void xsetflags(int f, int mask)
      { _flags = (_flags & ~mask) | (f & mask); }
    void gbump(int n)
      { _flags & 0x100 ? (_IO_save_base+=n):(_IO_read_ptr+=n);}
    void pbump(int n) { _IO_write_ptr += n; }
    void setb(char* b, char* eb, int a=0);
    void setp(char* p, char* ep)
      { _IO_write_base=_IO_write_ptr=p; _IO_write_end=ep; }
    void setg(char* eb, char* g, char *eg) {
      if (_flags & 0x100) _IO_free_backup_area(this); 
      _IO_read_base = eb; _IO_read_ptr = g; _IO_read_end = eg; }
    char *shortbuf() { return _shortbuf; }

    int in_backup() { return _flags & 0x100; }
     
    char *Gbase() { return in_backup() ? _IO_save_base : _IO_read_base; }
     
    char *eGptr() { return in_backup() ? _IO_save_end : _IO_read_end; }
     
    char *Bbase() { return in_backup() ? _IO_read_base : _IO_save_base; }
    char *Bptr() { return _IO_backup_base; }
     
    char *eBptr() { return in_backup() ? _IO_read_end : _IO_save_end; }
    char *Nbase() { return _IO_save_base; }
    char *eNptr() { return _IO_save_end; }
    int have_backup() { return _IO_save_base != __null; }
    int have_markers() { return _markers != __null; }
    void free_backup_area();
    void unsave_markers();  
    int put_mode() { return _flags & 0x800; }
    int switch_to_get_mode();
    
    streambuf(int flags=0);
  public:
    static int flush_all();
    static void flush_all_linebuffered();  
    virtual ~streambuf();
    virtual int overflow(int c = (-1));  
    virtual int underflow();  
    virtual int uflow();  
    virtual int pbackfail(int c);
 
    virtual streamsize xsputn(const char* s, streamsize n);
    virtual streamsize xsgetn(char* s, streamsize n);
    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);

    streampos pubseekoff(streamoff o, _seek_dir d, int mode=ios::in|ios::out)
      { return _IO_seekoff (this, o, d, mode); }
    streampos pubseekpos(streampos pos, int mode = ios::in|ios::out)
      { return _IO_seekpos (this, pos, mode); }
    streampos sseekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
    streampos sseekpos(streampos pos, int mode = ios::in|ios::out);
    virtual streambuf* setbuf(char* p, int len);
    virtual int sync();
    virtual int doallocate();

    int seekmark(streammarker& mark, int delta = 0);
    int sputbackc(char c);
    int sungetc();
    int unbuffered() { return _flags & 2 ? 1 : 0; }
    int linebuffered() { return _flags & 0x200 ? 1 : 0; }
    void unbuffered(int i)
	{ if (i) _flags |= 2; else _flags &= ~2; }
    void linebuffered(int i)
	{ if (i) _flags |= 0x200; else _flags &= ~0x200; }
    int allocate() {  
	if (base() || unbuffered()) return 0;
	else return doallocate(); }
     
    void allocbuf() { if (base() == __null) doallocbuf(); }
    void doallocbuf();
    int in_avail() { return _IO_read_end - _IO_read_ptr; }
    int out_waiting() { return _IO_write_ptr - _IO_write_base; }
    streamsize sputn(const char* s, streamsize n) { return xsputn(s, n); }
    streamsize padn(char pad, streamsize n) { return _IO_padn(this, pad, n); }
    streamsize sgetn(char* s, streamsize n) { return _IO_sgetn(this, s, n); }
    int ignore(int);
    int get_column();
    int set_column(int);
    long sgetline(char* buf, _G_size_t n, char delim, int putback_delim);
    int sputc(int c) { return _IO_putc(c, this); }
    int sbumpc() { return _IO_getc(this); }
    int sgetc() { return ((this)->_IO_read_ptr >= (this)->_IO_read_end 	  && __underflow (this) == (-1) ? (-1) 	: *(unsigned char *) (this)->_IO_read_ptr); }
    int snextc() {
	if (_IO_read_ptr >= _IO_read_end && __underflow(this) == (-1))
	  return (-1);
	else return _IO_read_ptr++, sgetc(); }
    void stossc() { if (_IO_read_ptr < _IO_read_end) _IO_read_ptr++; }
    int vscan(char const *fmt0, _G_va_list ap, ios* stream = __null);
    int scan(char const *fmt0 ...);
    int vform(char const *fmt0, _G_va_list ap);
    int form(char const *fmt0 ...);




    virtual streamsize sys_read(char* buf, streamsize size);
    virtual streamsize sys_write(const char*, streamsize);
    virtual streampos sys_seek(streamoff, _seek_dir);
    virtual int sys_close();
    virtual int sys_stat(void*);  




};

 
 

class filebuf : public streambuf {
  protected:
    void init();
  public:
    static const int openprot;  
    filebuf();
    filebuf(int fd);
    filebuf(int fd, char* p, int len);



    ~filebuf();
    filebuf* attach(int fd);
    filebuf* open(const char *filename, const char *mode);
    filebuf* open(const char *filename, ios::openmode mode, int prot = 0664);
    virtual int underflow();
    virtual int overflow(int c = (-1));
    int is_open() const { return _fileno >= 0; }
    int fd() const { return is_open() ? _fileno : (-1); }
    filebuf* close();
    virtual int doallocate();
    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
    virtual streambuf* setbuf(char* p, int len);
    streamsize xsputn(const char* s, streamsize n);
    streamsize xsgetn(char* s, streamsize n);
    virtual int sync();
  protected:  
 
    int is_reading() { return eback() != egptr(); }
    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
     
    char* file_ptr() { return eGptr(); }
     
    virtual streamsize sys_read(char* buf, streamsize size);
    virtual streampos sys_seek(streamoff, _seek_dir);
    virtual streamsize sys_write(const char*, streamsize);
    virtual int sys_stat(void*);  
    virtual int sys_close();




};

inline void ios::init(streambuf* sb, ostream* tie_to) {
		_state = sb ? ios::goodbit : ios::badbit; _exceptions=0;
		_strbuf=sb; _tie = tie_to; _width=0; _fill=' ';

		_flags=ios::skipws|ios::dec;



		_precision=6; _arrays = 0; }

inline ios::ios(streambuf* sb, ostream* tie_to) { init(sb, tie_to); }

inline ios::~ios() {



     
     
    operator delete[] (_arrays);
}
}  

# 31 "../../../egcs-20000410/libio/iostream.h" 2


extern "C++" {
class istream; class ostream;
typedef ios& (*__manip)(ios&);
typedef istream& (*__imanip)(istream&);
typedef ostream& (*__omanip)(ostream&);

extern istream& ws(istream& ins);
extern ostream& flush(ostream& outs);
extern ostream& endl(ostream& outs);
extern ostream& ends(ostream& outs);

class ostream : virtual public ios
{
     
    void do_osfx();
  public:
    ostream() { }
    ostream(streambuf* sb, ostream* tied=__null);
    int opfx() {
	if (!good()) return 0;
	else { if (_tie) _tie->flush();  ; return 1;} }
    void osfx() {  ;
		  if (flags() & (ios::unitbuf|ios::stdio))
		      do_osfx(); }
    ostream& flush();
    ostream& put(char c) { _strbuf->sputc(c); return *this; }





    ostream& write(const char *s, streamsize n);
    ostream& write(const unsigned char *s, streamsize n)
      { return write((const char*)s, n);}
    ostream& write(const signed char *s, streamsize n)
      { return write((const char*)s, n);}
    ostream& write(const void *s, streamsize n)
      { return write((const char*)s, n);}
    ostream& seekp(streampos);
    ostream& seekp(streamoff, _seek_dir);
    streampos tellp();
    ostream& form(const char *format ...);
    ostream& vform(const char *format, _G_va_list args);

    ostream& operator<<(char c);
    ostream& operator<<(unsigned char c) { return (*this) << (char)c; }
    ostream& operator<<(signed char c) { return (*this) << (char)c; }
    ostream& operator<<(const char *s);
    ostream& operator<<(const unsigned char *s)
	{ return (*this) << (const char*)s; }
    ostream& operator<<(const signed char *s)
	{ return (*this) << (const char*)s; }
    ostream& operator<<(const void *p);
    ostream& operator<<(int n);
    ostream& operator<<(unsigned int n);
    ostream& operator<<(long n);
    ostream& operator<<(unsigned long n);

    __extension__ ostream& operator<<(long long n);
    __extension__ ostream& operator<<(unsigned long long n);

    ostream& operator<<(short n) {return operator<<((int)n);}
    ostream& operator<<(unsigned short n) {return operator<<((unsigned int)n);}

    ostream& operator<<(bool b) { return operator<<((int)b); }

    ostream& operator<<(double n);
    ostream& operator<<(float n) { return operator<<((double)n); }



    ostream& operator<<(long double n) { return operator<<((double)n); }

    ostream& operator<<(__omanip func) { return (*func)(*this); }
    ostream& operator<<(__manip func) {(*func)(*this); return *this;}
    ostream& operator<<(streambuf*);



};

class istream : virtual public ios
{
     
protected:
    _G_size_t _gcount;

    int _skip_ws();
  public:
    istream(): _gcount (0) { }
    istream(streambuf* sb, ostream*tied=__null);
    istream& get(char* ptr, int len, char delim = '\n');
    istream& get(unsigned char* ptr, int len, char delim = '\n')
	{ return get((char*)ptr, len, delim); }
    istream& get(char& c);
    istream& get(unsigned char& c) { return get((char&)c); }
    istream& getline(char* ptr, int len, char delim = '\n');
    istream& getline(unsigned char* ptr, int len, char delim = '\n')
	{ return getline((char*)ptr, len, delim); }
    istream& get(signed char& c)  { return get((char&)c); }
    istream& get(signed char* ptr, int len, char delim = '\n')
	{ return get((char*)ptr, len, delim); }
    istream& getline(signed char* ptr, int len, char delim = '\n')
	{ return getline((char*)ptr, len, delim); }
    istream& read(char *ptr, streamsize n);
    istream& read(unsigned char *ptr, streamsize n)
      { return read((char*)ptr, n); }
    istream& read(signed char *ptr, streamsize n)
      { return read((char*)ptr, n); }
    istream& read(void *ptr, streamsize n)
      { return read((char*)ptr, n); }
    istream& get(streambuf& sb, char delim = '\n');
    istream& gets(char **s, char delim = '\n');
    int ipfx(int need = 0) {
	if (!good()) { set(ios::failbit); return 0; }
	else {
	   ;
	  if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
	  if (!need && (flags() & ios::skipws)) return _skip_ws();
	  else return 1;
	}
    }
    int ipfx0() {  
	if (!good()) { set(ios::failbit); return 0; }
	else {
	   ;
	  if (_tie) _tie->flush();
	  if (flags() & ios::skipws) return _skip_ws();
	  else return 1;
	}
    }
    int ipfx1() {  
	if (!good()) { set(ios::failbit); return 0; }
	else {
	   ;
	  if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
	  return 1;
	}
    }
    void isfx() {  ; }
    int get() { if (!ipfx1()) return (-1);
		else { int ch = _strbuf->sbumpc();
		       if (ch == (-1)) set(ios::eofbit);
		       isfx();
		       return ch;
		     } }
    int peek();
    _G_size_t gcount() { return _gcount; }
    istream& ignore(int n=1, int delim = (-1));
    int sync ();
    istream& seekg(streampos);
    istream& seekg(streamoff, _seek_dir);
    streampos tellg();
    istream& putback(char ch) {
	if (good() && _strbuf->sputbackc(ch) == (-1)) clear(ios::badbit);
	return *this;}
    istream& unget() {
	if (good() && _strbuf->sungetc() == (-1)) clear(ios::badbit);
	return *this;}
    istream& scan(const char *format ...);
    istream& vscan(const char *format, _G_va_list args);






    istream& operator>>(char*);
    istream& operator>>(unsigned char* p) { return operator>>((char*)p); }
    istream& operator>>(signed char*p) { return operator>>((char*)p); }
    istream& operator>>(char& c);
    istream& operator>>(unsigned char& c) {return operator>>((char&)c);}
    istream& operator>>(signed char& c) {return operator>>((char&)c);}
    istream& operator>>(int&);
    istream& operator>>(long&);

    __extension__ istream& operator>>(long long&);
    __extension__ istream& operator>>(unsigned long long&);

    istream& operator>>(short&);
    istream& operator>>(unsigned int&);
    istream& operator>>(unsigned long&);
    istream& operator>>(unsigned short&);

    istream& operator>>(bool&);

    istream& operator>>(float&);
    istream& operator>>(double&);
    istream& operator>>(long double&);
    istream& operator>>( __manip func) {(*func)(*this); return *this;}
    istream& operator>>(__imanip func) { return (*func)(*this); }
    istream& operator>>(streambuf*);
};

class iostream : public istream, public ostream
{
  public:
    iostream() { }
    iostream(streambuf* sb, ostream*tied=__null);
};

class _IO_istream_withassign : public istream {
public:
  _IO_istream_withassign& operator=(istream&);
  _IO_istream_withassign& operator=(_IO_istream_withassign& rhs)
    { return operator= (static_cast<istream&> (rhs)); }
};

class _IO_ostream_withassign : public ostream {
public:
  _IO_ostream_withassign& operator=(ostream&);
  _IO_ostream_withassign& operator=(_IO_ostream_withassign& rhs)
    { return operator= (static_cast<ostream&> (rhs)); }
};

extern _IO_istream_withassign cin;
 
extern _IO_ostream_withassign cout, cerr;

extern _IO_ostream_withassign clog



;

extern istream& lock(istream& ins);
extern istream& unlock(istream& ins);
extern ostream& lock(ostream& outs);
extern ostream& unlock(ostream& outs);

struct Iostream_init { } ;   

inline ios& dec(ios& i)
{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
inline ios& hex(ios& i)
{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
inline ios& oct(ios& i)
{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
}  


# 93 "../../../egcs-20000410/libstdc++/std/complext.cc" 2


template <class FLOAT> istream&
operator >> (istream& is, complex<FLOAT>& x)
{
  FLOAT re, im = 0;
  char ch = 0;

  if (is.ipfx0 ())
    {
      if (is.peek () == '(')
	is >> ch;
      is >> re;
      if (ch == '(')
	{
	  is >> ch;
	  if (ch == ',')
	    is >> im >> ch;
	}
    }
  is.isfx ();

  if (ch != 0 && ch != ')')
    is.setstate (ios::failbit);
  else if (is.good ())
    x = complex<FLOAT> (re, im);

  return is;
}

template <class FLOAT> ostream&
operator << (ostream& os, const complex<FLOAT>& x)
{
  return os << '(' << real (x) << ',' << imag (x) << ')';
}

 
 

 
# 154 "../../../egcs-20000410/libstdc++/std/complext.cc"

template <class FLOAT> complex<FLOAT>&
__doadv (complex<FLOAT>* ths, const complex<FLOAT>& y)
{
  FLOAT ar = abs (y.re);
  FLOAT ai = abs (y.im);
  FLOAT nr, ni;
  FLOAT t, d;
  if (ar <= ai)
    {
      t = y.re / y.im;
      d = y.im * (1 + t*t);
      nr = (ths->re * t + ths->im) / d;
      ni = (ths->im * t - ths->re) / d;
    }
  else
    {
      t = y.im / y.re;
      d = y.re * (1 + t*t);
      nr = (ths->re + ths->im * t) / d;
      ni = (ths->im - ths->re * t) / d;
    }
  ths->re = nr;
  ths->im = ni;
  return *ths;
}

template <class FLOAT> complex<FLOAT>
operator / (const complex<FLOAT>& x, const complex<FLOAT>& y)
{
  FLOAT ar = abs (real (y));
  FLOAT ai = abs (imag (y));
  FLOAT nr, ni;
  FLOAT t, d;
  if (ar <= ai)
    {
      t = real (y) / imag (y);
      d = imag (y) * (1 + t*t);
      nr = (real (x) * t + imag (x)) / d;
      ni = (imag (x) * t - real (x)) / d;
    }
  else
    {
      t = imag (y) / real (y);
      d = real (y) * (1 + t*t);
      nr = (real (x) + imag (x) * t) / d;
      ni = (imag (x) - real (x) * t) / d;
    }
  return complex<FLOAT> (nr, ni);
}

template <class FLOAT> complex<FLOAT>
operator / (FLOAT x, const complex<FLOAT>& y)
{
  FLOAT ar = abs (real (y));
  FLOAT ai = abs (imag (y));
  FLOAT nr, ni;
  FLOAT t, d;
  if (ar <= ai)
    {
      t = real (y) / imag (y);
      d = imag (y) * (1 + t*t);
      nr = x * t / d;
      ni = -x / d;
    }
  else
    {
      t = imag (y) / real (y);
      d = real (y) * (1 + t*t);
      nr = x / d;
      ni = -x * t / d;
    }
  return complex<FLOAT> (nr, ni);
}

template <class FLOAT> complex<FLOAT>
pow (const complex<FLOAT>& xin, int y)
{
  if (y == 0)
    return complex<FLOAT> (1.0);
  complex<FLOAT> r (1.0);
  complex<FLOAT> x (xin);
  if (y < 0)
    {
      y = -y;
      x = FLOAT(1)/x;
    }
  for (;;)
    {
      if (y & 1)
	r *= x;
      if (y >>= 1)
	x *= x;
      else
	return r;
    }
}

template <class FLOAT> complex<FLOAT>
sqrt (const complex<FLOAT>& x)
{
  FLOAT r = abs (x);
  FLOAT nr, ni;
  if (r == 0.0)
    nr = ni = r;
  else if (real (x) > 0)
    {
      nr = sqrt (0.5 * (r + real (x)));
      ni = imag (x) / nr / 2;
    }
  else
    {
      ni = sqrt (0.5 * (r - real (x)));
      if (imag (x) < 0)
	ni = - ni;
      nr = imag (x) / ni / 2;
    }
  return complex<FLOAT> (nr, ni); 
}
}  
# 29 "../../../egcs-20000410/libstdc++/cinst.cc" 2


typedef complex<f> c;
typedef const c& ccr;


template c& __doapl (c*, ccr);
template c& __doaml (c*, ccr);
template c& __doami (c*, ccr);
template c& __doadv (c*, ccr);



template c operator+ (ccr, ccr);


template c operator+ (ccr, f);


template c operator+ (f, ccr);


template c operator- (ccr, ccr);


template c operator- (ccr, f);


template c operator- (f, ccr);


template c operator* (ccr, ccr);


template c operator* (ccr, f);


template c operator* (f, ccr);


template c operator/ (ccr, ccr);


template c operator/ (ccr, f);


template c operator/ (f, ccr);


template c operator+ (ccr);


template c operator- (ccr);


template bool operator== (ccr, ccr);


template bool operator== (ccr, f);


template bool operator== (f, ccr);


template bool operator!= (ccr, ccr);


template bool operator!= (ccr, f);


template bool operator!= (f, ccr);


template f abs (ccr);


template f arg (ccr);


template c polar (f, f);


template c conj (ccr);


template f norm (ccr);


template c cos (ccr);


template c cosh (ccr);


template c exp (ccr);


template c log (ccr);


template c pow (ccr, ccr);


template c pow (ccr, f);


template c pow (ccr, int);


template c pow (f, ccr);


template c sin (ccr);


template c sinh (ccr);


template c sqrt (ccr);








Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]