🚀 go-pugleaf

Hello,

I have a problem with g++, that might be a bug. The program receives a fatal
signal 6, and according to the documentation, chapter 6, that is a bug. The
source file is probably not correct C++ and not error free by now, but the
compiler shouldn't receive an internal compiler error.

Version of gcc: 2.2.2
Architecture: HP/Apollo 425s, DomainOS 10.3.4

The compiler was installed using the original source with modifications for the
Apollo (not by me, but I think by J. Vasta).

The following is the source file produced by

[219]//isis/usr/otto/prog/apa$ gcc -E -DDEBUG -DTEST   ScnrScore.cc > gcc-bug.cc

[220]//isis/usr/otto/prog/apa$ g++ -c  -DDEBUG -DTEST  gcc-bug.cc -o gcc-bug.o
ScnrScore.cc: In method `ScnrScore::ScnrScore (int)':
ScnrScore.cc:15: type `ScnrScore' is not an immediate base class of type `ScnrScore'
cp-init.c:2871: failed assertion `has_array != 0'
/usr/local/bin/gcc: Internal compiler error: program cc1plus got fatal signal 6
	                 -----------------------------------------------------------
[222]//isis/usr/otto/prog/apa$ gcc -v
Reading specs from /usr/local/lib/gcc-lib/m68k-apollo-bsd/2.2.2/specs
gcc version 2.2.2[219]//isis/usr/otto/prog/apa$ gcc -E -DDEBUG -DTEST   ScnrScore.cc > gcc-bug.cc

# Cut here
#-----------------------------------------------------------------------------

# 1 "ScnrScore.cc"
 
static char RCSstring[] = "$Id$";

# 1 "ScnrScore.h" 1



# 1 "/usr/local/lib/g++-include/string.h" 1 3




# 1 "/usr/local/lib/g++-include/_G_config.h" 1 3
  





















 












 





 
 

# 5 "/usr/local/lib/g++-include/string.h" 2 3










extern "C" {

char*     strcat(char*, const char*);
char*     strchr(const char*, int);
int       strcmp(const char*, const char*);
int       strcoll(const char*, const char*);
char*     strcpy(char*, const char*);
unsigned long      strcspn(const char*, const char*);
char*     strdup(const char*);
 
 
 
 
unsigned long      strlen(const char*);
char*     strncat(char*, const char*, unsigned long  );
int       strncmp(const char*, const char*, unsigned long  );
char*     strncpy(char*, const char*, unsigned long  );
char*     strpbrk(const char*, const char*);
char*     strrchr(const char*, int);
unsigned long      strspn(const char*, const char*);
char*     strstr(const char*, const char *);
char*     strtok(char*, const char*);
unsigned long      strxfrm(char*, const char*, unsigned long  );

char*     index(const char*, int);
char*     rindex(const char*, int);
}

# 1 "/usr/local/lib/g++-include/memory.h" 1 3





# 1 "/usr/local/lib/g++-include/stddef.h" 1 3


extern "C" {



# 1 "/usr/local/lib/gcc-lib/m68k-apollo-bsd/2.2.2/include/stddef.h" 1 3



 









 


 





 


















 


typedef long int ptrdiff_t;









 


 




















 


typedef long unsigned int unsigned long  ;












 





















 


typedef long int wchar_t;












 









 






# 7 "/usr/local/lib/g++-include/stddef.h" 2 3




}

# 6 "/usr/local/lib/g++-include/memory.h" 2 3


extern "C" {

void*     memalign (...) ;
void*     memccpy (...) ;
void*     memchr (...) ;
int       memcmp (...) ;
void*     memcpy (...) ;
void*     memmove (...) ;
void*     memset (...) ;
int       ffs (...) ;
unsigned long     getpagesize (...) ;
void*     valloc (...) ;

void      bcopy (...) ;
int       bcmp (...) ;
void      bzero (...) ;
}














# 43 "/usr/local/lib/g++-include/string.h" 2 3



# 4 "ScnrScore.h" 2


# 1 "/usr/local/lib/g++-include/LEDA/vector.h" 1 3
 
















 
 
 




# 1 "/usr/local/lib/g++-include/LEDA/basic.h" 1 3
 


















# 1 "/usr/local/lib/g++-include/stdio.h" 1 3
 
 


















#pragma interface







 
 
 



extern "C" {

































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





# 1 "/usr/include/sys/stdsyms.h" 1 3
 











# 39 "/usr/include/sys/stdsyms.h" 3


# 60 "/usr/include/sys/stdsyms.h" 3







 






# 96 "/usr/include/sys/stdsyms.h" 3



# 7 "/usr/include/stdio.h" 2 3







 




 


 









 




 








 


 









 




























 










# 1 "/usr/include/sys/stdtypes.h" 1 3
 

 


























 






 






 






 































typedef void	*__va_list;















# 99 "/usr/include/stdio.h" 2 3



typedef struct _iobuf  {
	unsigned char	*_ptr  __attribute((aligned(1)));
	short		_cnt ;
	unsigned char	*_base  __attribute((aligned(1)));
	short		_flag ;
	short		_file ;
} FILE;

typedef unsigned long	fpos_t;

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


    extern "C" {


 
extern int 		remove 		(const char *__filename); 
extern int 		rename 		(const char *__old, const char *__new); 
extern FILE * 	tmpfile 	(void); 
extern char * 	tmpnam 		(char *__s); 

 
extern int 		fclose 		(FILE *__stream); 
extern int 		fflush 		(FILE *__stream); 
extern FILE * 	__hide_fopen  		(const char *__filename, const char *__mode); 
extern FILE * 	__hide_freopen  	(const char *__filename, const char *__mode, FILE *__stream); 
extern void 	__hide_setbuf  		(FILE *__stream, char *__buf); 
extern int 		__hide_setvbuf  	(FILE *__stream, char *__buf, int __mode, unsigned long   __size); 

 
extern int 		__hide_fprintf  	(FILE *__stream, const char *__format, ...); 
extern int 		__hide_fscanf  		(FILE *__stream, const char *__format, ...); 
extern int 		__hide_printf  		(const char *__format, ...); 
extern int 		__hide_scanf  		(const char *__format, ...); 

extern int 		__hide_sprintf  	(char *__s, const char *__format, ...); 



extern int 		__hide_sscanf  		(const char *__s, const char *__format, ...); 
extern int 		__hide_vfprintf  	(FILE *__stream, const char *__format, __va_list __arg); 
extern int 		__hide_vprintf  	(const char *__format, __va_list __arg); 
extern int 		__hide_vsprintf  	(char *__s, const char *__format, __va_list __arg); 

 
extern int 		fgetc 		(FILE *__stream); 
extern char * 	fgets 		(char *__s, int __n, FILE *__stream); 
extern int 		fputc 		(int __c, FILE *__stream); 
extern int 		__hide_fputs  		(const char *__s, FILE *__stream); 
extern int 		getc 		(FILE *__stream); 
extern int 		getchar 	(void); 
extern char * 	gets 		(char *__s); 
extern int 		putc 		(int __c, FILE *__stream); 
extern int 		putchar 	(int __c); 
extern int 		__hide_puts  		(const char *__s); 
extern int 		ungetc 		(int __c, FILE *__stream); 

 
extern unsigned long   	__hide_fread  	(void *_ptr , unsigned long   __size, unsigned long   __nmemb, FILE *__stream); 
extern unsigned long   	__hide_fwrite  	(const void *_ptr , unsigned long   __size, unsigned long   __nmemb, FILE *__stream); 

 
extern int 		fgetpos 	(FILE *__stream, fpos_t *__pos); 
extern int 		fseek 		(FILE *__stream, long int __offset, int __whence); 
extern int 		fsetpos 	(FILE *__stream, const fpos_t *__pos); 
extern long 	__hide_ftell  		(FILE *__stream); 
extern void 	__hide_rewind  		(FILE *__stream); 

 
extern void 	clearerr 	(FILE *__stream); 
extern int 		feof 		(FILE *__stream); 
extern int 		ferror 		(FILE *__stream); 
extern void 	__hide_perror  		(const char *__s); 

 
extern int 		_filbuf  	(FILE *__iop); 
extern int 		__hide__flsbuf   	(unsigned __c, FILE *__iop); 



extern FILE * 	__hide_fdopen  		(int __filedes, const char *__type); 
extern int 		fileno 		(const FILE *__stream); 





 
extern int 		getw 		(FILE *__stream); 
extern int 		__hide_putw  		(int __w, FILE *__stream); 

extern int 		pclose 		(FILE *__stream); 
extern FILE * 	__hide_popen  		(const char *__command, const char *__type); 

extern char * 	__hide_tempnam  	(const char *__dir, const char *__pfx); 





extern char * 	ctermid 	(char *__s); 
extern char * 	cuserid 	(char *__s); 
extern void 	__hide_setbuffer  	(FILE *__stream, char *__buf, int __siz); 
extern void 	__hide_setlinebuf  	(FILE *__stream); 
extern int 		system 		(const char *__command); 




    }


 



































# 69 "/usr/local/lib/g++-include/stdio.h" 2 3







































}

extern "C" {

int    fclose(FILE*);
FILE*  fdopen(int, const char*);
int    fflush(FILE*);
int    fgetc(FILE*);
char*  fgets(char*, int, FILE *);
FILE*  fopen(const char*, const char*);
int    fprintf(FILE*, const char* ...);
int    fputc(int, FILE*);
int    fputs(const char*, FILE*);
unsigned long   fread(void*, unsigned long  , unsigned long  , FILE*);



FILE*  freopen(const char*, const char*, FILE*);

int    fscanf(FILE*, const char* ...);
int    fseek(FILE*, long, int);
long   ftell(FILE *);
unsigned long   fwrite(const void*, unsigned long  , unsigned long  , FILE*);
char*  gets(char*);
int    getw(FILE*);
int    pclose(FILE*);
void   perror(const char*);
FILE*  popen(const char*, const char*);
int    printf(const char* ...);
int    puts(const char*);
int    putw(int, FILE*);
int    rewind(FILE*);
int    scanf(const char* ...);
void   setbuf(FILE*, char*);
void   setbuffer(FILE*, char*, int);
int    setlinebuf(FILE*);
int    setvbuf(FILE*, char*, int, unsigned long  );
int    sscanf(char*, const char* ...);
FILE*  tmpfile();
int    ungetc(int, FILE*);
int    vfprintf (...) ;
int    vprintf (...) ;
int  sprintf (...) ;
int  vsprintf (...) ;

extern int _filbuf (...) ;
extern int _flsbuf (...) ;

}


















# 20 "/usr/local/lib/g++-include/LEDA/basic.h" 2 3

# 1 "/usr/local/lib/g++-include/stdlib.h" 1 3







extern "C" {

int       abs(int);


void volatile abort(void);




double    atof(const char*);
int       atoi(const char*);
long      atol(const char*);

int       atexit(auto void (*p) (void));
int       bsearch (const void *, const void *, unsigned long  , 
                   unsigned long  , auto int (*ptf)(const void*, const void*));
void*     calloc(unsigned long  , unsigned long  );
void      cfree(void*);


void volatile exit(int);




char*     fcvt(double, int, int*, int*);
void      free(void*);
char*     getenv(const char*);
int       getopt(int, char * const *, const char*);
int       getpw(int, char*);
char*     gcvt(double, int, char*);
char*     ecvt(double, int, int*, int*);
extern char**   environ;

long      labs(long);
void*     malloc(unsigned long  );
unsigned long      malloc_usable_size(void*);
int       putenv(const char*);
extern char*    optarg;
extern int      opterr;
extern int      optind;
void      qsort(void*, unsigned long  , unsigned long  , auto int (*ptf)(void*,void*));
int       rand(void);
void*     realloc(void*, unsigned long  );
int       setkey(const char*);
int       srand(unsigned int);
double    strtod(const char*, char**);
long      strtol(const char*, char**, int);
unsigned long stroul(const char**, int);
int       system(const char*);

long      random(void);
void      srandom(int);
char*     setstate(char*);
char*     initstate(unsigned, char*, int);

double    drand48(void);
void      lcong48(short*);
long      jrand48(short*);
long      lrand48(void);
long      mrand48(void);
long      nrand48(short*);
short*    seed48(short*);
void      srand48(long);

char*     ctermid(char*);
char*     cuserid(char*);
char*     tempnam(const char*, const char*);
char*     tmpnam(char*);

}

# 21 "/usr/local/lib/g++-include/LEDA/basic.h" 2 3


 
 
 


 






# 1 "/usr/local/lib/g++-include/iostream.h" 1 3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 



#pragma interface




# 1 "/usr/local/lib/g++-include/streambuf.h" 1 3
 
 
 
 
 
 
 
 
 
 
 
 
 
 





#pragma interface

















class ostream; class streambuf; class backupbuf;





extern "C" int __underflow(streambuf*);
extern "C" int __overflow(streambuf*, int);

typedef long  streamoff;
typedef long  streampos;  

typedef unsigned long __fmtflags;
typedef unsigned char __iostate;

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














# 87 "/usr/local/lib/g++-include/streambuf.h" 3


class ios : public _ios_fields {
  public:
    typedef __fmtflags fmtflags;
    typedef __iostate iostate;
    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  };
    enum seek_dir { beg, cur, end};
    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=0100000, unitbuf=020000, stdio=040000,
	   dont_close=0x80000000  
	   };

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

     
    char fill() const { return _fill; }
    char fill(char newf) { char 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 & mask;
	_flags &= ~mask; return oldbits; }
    int width() const { return _width; }
    int width(int val) { int save = _width; _width = val; return save; }

    static const unsigned long basefield;
    static const unsigned long adjustfield;
    static const unsigned long floatfield;

    streambuf* rdbuf() const { return _strbuf; }
    void clear(iostate state = 0) { _state = state; }
    void set(iostate flag) { _state |= flag; }  
    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; }
    int rdstate() const { return _state; }
    operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
    int operator!() const { return fail(); }









  protected:
    ios(streambuf* sb = 0, ostream* tie = 0);
    ~ios();
};




typedef ios::seek_dir _seek_dir;


 
 
 
 
 



















 
 
class streammarker {
    friend class streambuf;



    friend int __underflow(streambuf*);

    struct streammarker *_next;   
    streambuf *_sbuf;  
    streampos _spos;  
    void set_streampos(streampos sp) { _spos = sp; }
    void set_offset(int offset) { _pos = offset; _spos = (streampos)(-2); }
     
     
    int _pos;
  public:
    streammarker(streambuf *sb);
    ~streammarker();
    int saving() { return  _spos == -2; }
    int delta(streammarker&);
    int delta();
};

struct __streambuf {
     
    int _flags;		 
    char* _gptr;	 
    char* _egptr;	 
    char* _eback;	 
    char* _pbase;	 
    char* _pptr;	 
    char* _epptr;	 
    char* _base;	 
    char* _ebuf;	 
    struct streambuf *_chain;

     
    friend class streammarker;
    char *_other_gbase;  
    char *_aux_limit;   
    char *_other_egptr;  
    streammarker *_markers;


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

extern unsigned __adjust_column(unsigned start, const char *line, int count);

struct streambuf : private __streambuf {
    friend class ios;
    friend class istream;
    friend class ostream;
    friend class streammarker;



    friend int __underflow(streambuf*);

  protected:
    static streambuf* _list_all;  
    streambuf*& xchain() { return _chain; }
    void _un_link();
    void _link_in();
    char* gptr() const { return _gptr; }
    char* pptr() const { return _pptr; }
    char* egptr() const { return _egptr; }
    char* epptr() const { return _epptr; }
    char* pbase() const { return _pbase; }
    char* eback() const { return _eback; }
    char* ebuf() const { return _ebuf; }
    char* base() const { return _base; }
    void xput_char(char c) { *_pptr++ = 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) { _gptr += n; }
    void pbump(int n) { _pptr += n; }
    void setb(char* b, char* eb, int a=0);
    void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
    void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
    char *shortbuf() { return _shortbuf; }

    int in_backup() { return _flags & 0x100 ; }
     
    char *Gbase() { return in_backup() ? _other_gbase : _eback; }
     
    char *eGptr() { return in_backup() ? _other_egptr : _egptr; }
     
    char *Bbase() { return in_backup() ? _eback : _other_gbase; }
    char *Bptr() { return _aux_limit; }
     
    char *eBptr() { return in_backup() ? _egptr : _other_egptr; }
    char *Nbase() { return _other_gbase; }
    char *eNptr() { return _other_egptr; }
    int have_backup() { return _other_gbase != 0 ; }
    int have_markers() { return _markers != 0 ; }
    int _least_marker();
    void switch_to_main_get_area();
    void switch_to_backup_area();
    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 int underflow() = 0;  
    virtual int overflow(int c = 	(-1) ) = 0;  
    virtual int doallocate();
    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
    int seekmark(streammarker& mark, int delta = 0);
    int sputbackc(char c);
    int sungetc();
    virtual ~streambuf();
    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() == 0 ) doallocbuf(); }
    void doallocbuf();
    virtual int sync();
    virtual int pbackfail(int c);
    virtual int ungetfail();
    virtual streambuf* setbuf(char* p, int len);
    int in_avail() { return _egptr - _gptr; }
    int out_waiting() { return _pptr - _pbase; }
    virtual int sputn(const char* s, int n);
    int padn(char pad, int n);  
    virtual int sgetn(char* s, int n);
    int ignore(int);
    virtual int get_column();
    virtual int set_column(int);
    long sgetline(char* buf, unsigned long  n, char delim, int putback_delim);
    int sbumpc() {
	if (_gptr >= _egptr && __underflow(this) == 	(-1) ) return 	(-1) ;
	else return *(unsigned char*)_gptr++; }
    int sgetc() {
	if (_gptr >= _egptr && __underflow(this) == 	(-1) ) return 	(-1) ;
	else return *(unsigned char*)_gptr; }
    int snextc() {
	if (++_gptr >= _egptr && __underflow(this) == 	(-1) ) return 	(-1) ;
	else return *(unsigned char*)_gptr; }
    int sputc(int c) {
	if (_pptr >= _epptr) return __overflow(this, (unsigned char)c);
	return *_pptr++ = c, (unsigned char)c; }
    void stossc() { if (_gptr < _egptr) _gptr++; }
    int vscan(char const *fmt0, char*  ap, ios::iostate* = 0 );
    int vform(char const *fmt0, char*  ap);




};

 
 

 
 
 
 

class backupbuf : public streambuf {
    friend class streammarker;
  protected:
    backupbuf(int flags=0) : streambuf(flags|0x4000 ) { }
  public:
    virtual int pbackfail(int c);
    virtual int underflow();
    virtual int overflow(int c = 	(-1) );
};

struct __file_fields {
    short _fileno;
    int _blksize;
    unsigned long   _offset;
 
};

class filebuf : public backupbuf {
  protected:
    struct __file_fields _fb;
    void init();
  public:
    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, int mode, int prot = 0664);
    virtual int underflow();
    virtual int overflow(int c = 	(-1) );
    int is_open() { return _fb._fileno >= 0; }
    int fd() { return is_open() ? _fb._fileno : 	(-1) ; }
    filebuf* close();
    virtual int doallocate();
    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
    int sputn(const char* s, int n);
    int sgetn(char* s, int n);
    virtual int sync();
  protected:  
 
    int is_reading() { return eback() != egptr(); }
    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
     
    char* file_ptr() { return eGptr(); }
    int do_write(const char *data, int to_do);
    int do_flush() { return do_write(_pbase, _pptr-_pbase); }
     
    virtual long  sys_read(char* buf, unsigned long  size);
    virtual unsigned long   sys_seek(unsigned long  , _seek_dir);
    virtual long  sys_write(const void*, long);
    virtual int sys_stat(void*);  
    virtual int sys_close();
};







inline ios::ios(streambuf* sb  , ostream* tie  ) {
		_tie = tie; _strbuf=sb; _state=0; _width=0; _fill=' ';
		_flags=ios::skipws; _precision=6; }
inline ios::~ios() {
    if (!(_flags & (unsigned int)ios::dont_close)) delete _strbuf; }


# 25 "/usr/local/lib/g++-include/iostream.h" 2 3


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 : public ios
{
    void do_osfx();
  public:
    ostream() { }
    ostream(streambuf* sb, ostream* tied=0 );
    int opfx() { if (!good()) return 0; if (_tie) _tie->flush(); return 1; }
    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
		      do_osfx(); }
    streambuf* ostreambuf() const { return _strbuf; }
    ostream& flush();
    ostream& put(char c) { _strbuf->sputc(c); return *this; }

    ostream& write(const char *s, int n);
    ostream& write(const unsigned char *s, int n) { return write((const char*)s, n);}

    ostream& write(const signed char *s, int n) { return write((const char*)s, n);}

    ostream& write(const void *s, int 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, char*  args);
};

extern ostream& operator<<(ostream&, char c);
inline ostream& operator<<(ostream& os, unsigned char c)
{ return os << (char)c; }

extern ostream& operator<<(ostream &os, signed char c) { return os << (char)c;}

extern ostream& operator<<(ostream&, const char *s);
inline ostream& operator<<(ostream& os, const unsigned char *s)
{ return os << (const char*)s; }

inline ostream& operator<<(ostream& os, const signed char *s)
{ return os << (const char*)s; }

extern ostream& operator<<(ostream&, void *p);
extern ostream& operator<<(ostream&, int n);
extern ostream& operator<<(ostream&, long n);
extern ostream& operator<<(ostream&, unsigned int n);
extern ostream& operator<<(ostream&, unsigned long n);
inline ostream& operator<<(ostream& os, short n) {return os << (int)n;}
inline ostream& operator<<(ostream& os, unsigned short n)
{return os << (unsigned int)n;}
extern ostream& operator<<(ostream&, float n);
extern ostream& operator<<(ostream&, double n);
inline ostream& operator<<(ostream& os, __omanip func) { return (*func)(os); }
inline ostream& operator<<(ostream& os, __manip func) {(*func)(os); return os;}
extern ostream& operator<<(ostream&, streambuf*);

class istream : public ios
{
    long  _gcount;

    int _skip_ws();
  public:
    istream() { _gcount = 0; }
    istream(streambuf* sb, ostream*tied=0 );
    streambuf* istreambuf() const { return _strbuf; }
    istream& get(char& c);
    istream& get(unsigned char& c) { return get((char&)c); }

    istream& get(signed char& c)  { return get((char&)c); }

    istream& read(char *ptr, int n);
    istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }

    istream& read(signed char *ptr, int n) { return read((char*)ptr, n); }

    istream& read(void *ptr, int n) { return read((char*)ptr, n); }
     
    istream& getline(char* ptr, int len, char delim = '\n');
    istream& get(char* ptr, int len, char delim = '\n');
    istream& get(streambuf& sb, char delim = '\n');
    istream& gets(char **s, char delim = '\n');
    int ipfx(int need) {
	if (!good()) { set(ios::failbit); return 0; }
	if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
	if (!need && (flags() & ios::skipws)) return _skip_ws();
	return 1;
    }
    int ipfx0() {  
	if (!good()) { set(ios::failbit); return 0; }
	if (_tie) _tie->flush();
	if (flags() & ios::skipws) return _skip_ws();
	return 1;
    }
    int ipfx1() {  
	if (!good()) { set(ios::failbit); return 0; }
	if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
	return 1;
    }
    int get() { if (!ipfx1()) return 	(-1) ;
		int ch = _strbuf->sbumpc();
		if (ch == 	(-1) ) set(ios::eofbit);
		return ch; }
    int peek() { if (!ipfx1()) return 	(-1) ;
		int ch = _strbuf->sgetc();
		if (ch == 	(-1) ) set(ios::eofbit);
		return ch; }
    long  gcount() { return _gcount; }
    istream& ignore(int n=1, int delim = 	(-1) );
    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, char*  args);




};

extern istream& operator>>(istream&, char*);
inline istream& operator>>(istream& is, unsigned char* p)
{ return is >> (char*)p; }

inline istream& operator>>(istream& is, signed char*p) {return is >> (char*)p;}

extern istream& operator>>(istream&, char& c);
extern istream& operator>>(istream& s, unsigned char& c) {return s>>(char&)c;}

extern istream& operator>>(istream& s, signed char& c) {return s >> (char&)c;}

extern istream& operator>>(istream&, int&);
extern istream& operator>>(istream&, long&);
extern istream& operator>>(istream&, short&);
extern istream& operator>>(istream&, unsigned int&);
extern istream& operator>>(istream&, unsigned long&);
extern istream& operator>>(istream&, unsigned short&);
extern istream& operator>>(istream&, float&);
extern istream& operator>>(istream&, double&);
inline istream& operator>>(istream& is, __manip func) {(*func)(is); return is;}
inline istream& operator>>(istream& is, __imanip func) { return (*func)(is); }
extern istream& operator>>(istream&, streambuf*);

class iostream : public ios {
    long  _gcount;
  public:
    iostream() { _gcount = 0; }
    iostream(streambuf* sb, ostream*tied=0 );
    operator istream&() { return *(istream*)this; }
    operator ostream&() { return *(ostream*)this; }
     
    istream& get(char& c) { return ((istream*)this)->get(c); }
    istream& get(unsigned char& c) { return ((istream*)this)->get((char&)c); }

    istream& get(signed char& c) { return ((istream*)this)->get((char&)c); }

    istream& read(char *ptr, int n) { return ((istream*)this)->read(ptr, n); }
    istream& read(unsigned char *ptr, int n)
	{ return ((istream*)this)->read((char*)ptr, n); }

    istream& read(signed char *ptr, int n)
	{ return ((istream*)this)->read((char*)ptr, n); }

    istream& read(void *ptr, int n)
	{ return ((istream*)this)->read((char*)ptr, n); }
    istream& getline(char* ptr, int len, char delim = '\n')
	{ return ((istream*)this)->getline(ptr, len, delim); }
    istream& get(char* ptr, int len, char delim = '\n')
	{ return ((istream*)this)->get(ptr, len, delim); }
    istream& gets(char **s, char delim = '\n')
	{ return ((istream*)this)->gets(s, delim); }
    istream& ignore(int n=1, int delim = 	(-1) )
	{ return ((istream*)this)->ignore(n, delim); }
    int ipfx(int need) { return ((istream*)this)->ipfx(need); }
    int ipfx0()  { return ((istream*)this)->ipfx0(); }
    int ipfx1()  { return ((istream*)this)->ipfx1(); }
    int get() { return _strbuf->sbumpc(); }
    int peek() { return ipfx1() ? _strbuf->sgetc() : 	(-1) ; }
    long  gcount() { return _gcount; }
    istream& putback(char ch) { return ((istream*)this)->putback(ch); }
    istream& unget() { return ((istream*)this)->unget(); }
    istream& seekg(streampos pos) { return ((istream*)this)->seekg(pos); }
    istream& seekg(streamoff off, _seek_dir dir)
	{ return ((istream*)this)->seekg(off, dir); }
    streampos tellg() { return ((istream*)this)->tellg(); }
    istream& scan(const char *format ...);
    istream& vscan(const char *format, char*  args)
	{ return ((istream*)this)->vscan(format, args); }




     
    int opfx() { return ((ostream*)this)->opfx(); }
    void osfx() { ((ostream*)this)->osfx(); }
    ostream& flush() { return ((ostream*)this)->flush(); }
    ostream& put(char c) { return ((ostream*)this)->put(c); }
    ostream& write(const char *s, int n)
	{ return ((ostream*)this)->write(s, n); }
    ostream& write(const unsigned char *s, int n)
	{ return ((ostream*)this)->write((const char*)s, n); }

    ostream& write(const signed char *s, int n)
	{ return ((ostream*)this)->write((const char*)s, n); }

    ostream& write(const void *s, int n)
	{ return ((ostream*)this)->write((const char*)s, n); }
    ostream& form(const char *format ...);
    ostream& vform(const char *format, char*  args)
	{ return ((ostream*)this)->vform(format, args); }
    ostream& seekp(streampos pos) { return ((ostream*)this)->seekp(pos); }
    ostream& seekp(streamoff off, _seek_dir dir)
	{ return ((ostream*)this)->seekp(off, dir); }
    streampos tellp() { return ((ostream*)this)->tellp(); }
};

extern istream cin;
extern ostream cout, cerr, clog;  

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


# 35 "/usr/local/lib/g++-include/LEDA/basic.h" 2 3






# 1 "/usr/local/lib/g++-include/values.h" 1 3
 
 










































# 150 "/usr/local/lib/g++-include/values.h" 3

























# 41 "/usr/local/lib/g++-include/LEDA/basic.h" 2 3










# 1 "/usr/local/lib/g++-include/generic.h" 1 3
 
 



















 





















extern genericerror(int,char*);
typedef int (*GPT)(int,char*);









# 51 "/usr/local/lib/g++-include/LEDA/basic.h" 2 3

# 63 "/usr/local/lib/g++-include/LEDA/basic.h" 3









 
 
 


typedef void* GenPtr;     

typedef int     (*CMP_PTR)    (GenPtr&,GenPtr&);
typedef GenPtr  (*PTR_TO_PTR) (GenPtr&);
typedef int     (*PTR_TO_INT) (GenPtr&);
typedef void    (*PTR_TO_VOID)(GenPtr&);


 
 
 

struct LEDA_SIMPLE { 

GenPtr PTR;

friend int  compare(const LEDA_SIMPLE& x, const LEDA_SIMPLE& y) 
                                      { return int(x.PTR) - int(y.PTR);}

friend void Print(const LEDA_SIMPLE& x, ostream& out = cout) 
                                      { out << "L" << int(x.PTR); }

friend void Read(LEDA_SIMPLE&, istream& = cin) {}
friend void Clear(LEDA_SIMPLE&)             {}
friend void Init(LEDA_SIMPLE&)              {}
friend GenPtr Copy(const LEDA_SIMPLE& y)    { return y.PTR; }
friend GenPtr Convert(const LEDA_SIMPLE& y) { return y.PTR; }

};


 
 
 

















































 









 
 
 

struct  memory_elem_type { memory_elem_type* next; };
typedef memory_elem_type* memory_elem_ptr;

extern memory_elem_ptr memory_free_list[];

extern memory_elem_ptr memory_allocate_block(int);
extern memory_elem_ptr allocate_bytes(int);
extern memory_elem_ptr allocate_words(int);
extern void            deallocate_bytes(void*,int);
extern void            deallocate_words(void*,int);
extern void            deallocate_list(void*,void*,int);
extern void            memory_clear();
extern void            memory_kill();
extern void            print_statistics();

























 
 
 
 


 

inline int compare(GenPtr x, GenPtr y) { return int(x)-int(y); }
inline int compare(char x, char y)     { return x-y; }
inline int compare(int  x, int  y)     { return x-y; }
inline int compare(long x, long y)     { return x-y; }


inline int compare(double x, double y) 
{ if (x < y)  return -1;  
  else if (x > y)  return  1;  
  else return 0; 
}


inline int compare(float x, float y) 
{ if (x < y)  return -1;  
  else if (x > y)  return  1;  
  else return 0; 
}


 

inline void Print(const GenPtr x, ostream& out = cout) { out << int(x); }
inline void Print(char x, ostream& out = cout)         { out << x; }
inline void Print(int  x, ostream& out = cout)         { out << x; }
inline void Print(long x, ostream& out = cout)         { out << x; }
inline void Print(float x, ostream& out = cout)        { out << x; }
inline void Print(double x, ostream& out = cout)       { out << x; }



 

inline void Read(GenPtr,   istream&)          {}
inline void Read(char& x,  istream& in = cin) { in >> x; }
inline void Read(int&  x,  istream& in = cin) { in >> x; }
inline void Read(long& x,  istream& in = cin) { in >> x; }
inline void Read(float& x, istream& in = cin) { in >> x;}
inline void Read(double& x,istream& in = cin) { in >> x;}



 

inline void Init(GenPtr)    {}
inline void Init(char&   x) { x=0; }
inline void Init(int&    x) { x=0; }
inline void Init(long&   x) { x=0; }
inline void Init(float&  x) { x=0; }
inline void Init(double& x) { x=0; }


 

inline void Clear(GenPtr)   {}
inline void Clear(char  )   {}
inline void Clear(int   )   {}
inline void Clear(long  )   {}
inline void Clear(float )   {}
inline void Clear(double& x) { deallocate_bytes(&x,sizeof(double)); }


 
 

inline GenPtr Copy(GenPtr x)  { return x; }
inline GenPtr Copy(char x)    { return GenPtr(x); }
inline GenPtr Copy(int  x)    { return GenPtr(x); }
inline GenPtr Copy(long x)    { return GenPtr(x); }
inline GenPtr Copy(float x)   { return *(GenPtr*)&x; }
inline GenPtr Copy(const double& x) 
                         { double* p = (double*)allocate_bytes(sizeof(double)); 
                           *p = x; return p; }


 

inline GenPtr Convert(GenPtr x)        { return x; }
inline GenPtr Convert(int  x)          { return GenPtr(x); }
inline GenPtr Convert(long x)          { return GenPtr(x); }
inline GenPtr Convert(float x)         { return *(GenPtr*)&x; }
inline GenPtr Convert(const double& x) { return GenPtr(&x); }


 

inline GenPtr&  Access(GenPtr, const GenPtr& p) { return *(GenPtr*)&p; }
inline int&     Access(int,    const GenPtr& p) { return *(int*)&p;  }
inline long&    Access(long,   const GenPtr& p) { return *(long*)&p; }
inline float&   Access(float,  const GenPtr& p) { return *(float*)&p;}
inline double&  Access(double, const GenPtr& p) { return *(double*)p;} 


 




























 
 
 

enum rel_pos { before = 1, after = 0 };

enum direction { forward = 0, backward = 1 };


 
 
 

typedef int bool;        








extern const bool true;
extern const bool false;




 
 
 


class srep { 

public:

      char*   s;       
      int count;       

 srep(const char*);

~srep() { delete s; }

  void* operator new(unsigned long  ){ memory_elem_ptr* q = &(memory_free_list[sizeof(srep)]); if (*q==0) *q = memory_allocate_block(sizeof(srep)); memory_elem_ptr p = *q; *q = p->next; return p; } void  operator delete(void* p){ memory_elem_ptr* q = &(memory_free_list[sizeof(srep)]); memory_elem_ptr(p)->next = *q; *q = memory_elem_ptr(p); } 

# 388 "/usr/local/lib/g++-include/LEDA/basic.h" 3

};


class format_string
{ friend class string;
  const char* str;
  public:
  format_string(const char* s) { str = s; }
 };


class string  : public LEDA_SIMPLE 
{

friend class srep;

static char* str_dup(const char*);
static char* str_cat(const char*,const char*);
static char* str_cat(int, char**);

srep*  ptr() const { return (srep*)PTR; }

public:

 string()                { PTR = new srep(""); }
 string(const string& x) { PTR = x.ptr();  ptr()->count++; }
 string(int argc, char** argv) 
                         { PTR = new srep(str_cat(argc,argv)); }

 




 string(const char*, ...);    



 string(const char* s)   { PTR = new srep(s);}




void clear()  { if (--ptr()->count==0) delete ptr(); }

~string()     { clear(); }


char*  operator~()  const   { return str_dup(ptr()->s); }
char*  cstring()    const   { return ptr()->s; }

int    length()          const;
string sub(int,int)      const;
int    pos(string,int=0) const;

string operator()(int i, int j)  const { return sub(i,j); }
string head(int i)               const { return sub(0,i-1); }
string tail(int i)               const { return sub(length()-i,length()-1); }

string insert(string, int=0)     const;
string insert(int, string)       const;

string replace(string, string, int=1) const; 
string replace(int, int, string) const; 

string del(string, int=1)    const; 
string del(int, int)         const; 

void   read(istream&, char=' ');
void   read(char delim=' ')     { read(cin,delim); }

string replace_all(string s1, string s2) const  { return replace(s1,s2,0); } 
string replace(int i, string s)          const  { return replace(i,i,s);  } 

string del_all(string s)                 const  { return del(s,0); }
string del(int i)                        const  { return del(i,i); }  

void   read_line(istream& I = cin)              { read(I,'\n'); }

string format(string) const;

int    refs() const { return ptr()->count; }

string& operator=(const char*);
string& operator=(const string&);

char  operator[](int) const;
char& operator[](int);

string operator+(const string& x)  const;
string operator+(const char* s1)   const;
string& operator+=(const char* s1);
string& operator+=(const string& x);


friend int operator==(const string& x, const char* s);
friend int operator==(const string& x, const string& y);
friend int operator!=(const string& x, const char* s);
friend int operator!=(const string& x, const string& y);
friend int operator< (const string& x, const string& y);
friend int operator> (const string& x, const string& y);
friend int operator<=(const string& x, const string& y);
friend int operator>=(const string& x, const string& y);


friend istream& operator>>(istream&, string&); 
friend ostream& operator<<(ostream&, const string&) ;

friend void Print(const string& x, ostream& out = cout) { out << x; }
friend void Read(string&  x, istream& in = cin)   { in  >> x; }


friend GenPtr  Copy(const string& x) { x.ptr()->count++;  return x.PTR; }
friend void    Clear(string& x)      { x.clear(); }
friend string& Access(const string&, const GenPtr& p){ return *(string*)&p; }

friend int  compare(const string& x, const string& y);


};

 
 
 




# 525 "/usr/local/lib/g++-include/LEDA/basic.h" 3


 
 
 




# 551 "/usr/local/lib/g++-include/LEDA/basic.h" 3




 
 
 

typedef int (*SIG_PF) (...);

extern SIG_PF signal(int, SIG_PF);

extern int interrupt_handler(...);

inline SIG_PF catch_interrupts(SIG_PF handler = interrupt_handler)
{ return signal(2,handler); }



extern void     init_random(int=0);
extern double   rrandom();                    
extern int      random(int a, int b);         
extern unsigned random(unsigned, unsigned);

extern float used_time();
extern float used_time(float&);
extern void  print_time(string s);

inline void print_time() { print_time(""); }

extern void wait(unsigned int seconds);


 
 
 

 
















extern int     Yes(string s);
extern int     Yes();

extern int     read_int(string s);
extern int     read_int();

extern char    read_char(string s);
extern char    read_char();

extern double  read_real(string s);
extern double  read_real();

extern char*  read_string(string s);
extern char*  read_string();

extern char*  read_line(istream& s);
extern char*  read_line();


 
 
 

typedef void (*PEH)(int,char*);    

extern PEH p_error_handler;
extern PEH set_error_handler(PEH);
extern void default_error_handler(int,char*);


inline void error_handler(int i, char* s)  { p_error_handler(i,s); }
inline void error_handler(int i, string s) { p_error_handler(i,~s); }


 
 
 

extern const char* leda_version_string;

class LEDA_INIT {

char* init_list;

public:

 LEDA_INIT();
~LEDA_INIT();

};

extern LEDA_INIT L_E_D_A;


# 25 "/usr/local/lib/g++-include/LEDA/vector.h" 2 3



class vector
{
  friend class matrix;

  double* v;
  int d;

  void check_dimensions(const vector&) const;
 
public:

  vector(int=0); 
  vector(double, double);
  vector(double, double, double);
  vector(const vector&);
 ~vector() { if (v) delete v; }
 

  double length() const;
  
  int    dim()    const { return d; }
  vector norm()   const { return *this/length(); }
  
  double angle(const vector&) const; 
  
  vector& operator=(const vector&);
  
  double& operator[](int);
  double  operator[](int) const;
                                             
   
  double& elem( int n )					{ return v[n]; }
  double  elem( int n ) const			{ return v[n]; }
  
  vector  operator+(const vector&) const;
  vector  operator-(const vector&) const;
  vector  operator*(double)        const;
  vector  operator/(double)        const;
  double  operator*(const vector&) const;  
                           
   
  vector & add(const vector&);
  vector & sub(const vector&);
  vector & mul(double);
  vector & div(double);
  
  int     operator==(const vector&) const;
  int     operator!=(const vector& w)  const { return !(*this == w); }
  
   



  
  friend ostream& operator<<(ostream& o, const vector& v);
  friend istream& operator>>(istream& i, vector& v);
  
  friend void Print(const vector& v, ostream& out=cout) { out << v; } 
  friend void Read(vector& v, istream& in=cin)  { in >> v; }
  
  friend void   Init(vector& x)          { x = vector(0); }
  friend void   Clear(vector& x)         { delete (vector*)&x; }
  friend GenPtr Copy(vector& x)          { return new vector(x); }
  friend GenPtr Convert(vector& x)       { return &x; }
  friend vector& Access(const vector&, const GenPtr& p) { return *(vector*)p; }
  friend int compare(const vector&, const vector&) { return 0; }
  
  void* operator new(unsigned long  ){ memory_elem_ptr* q = &(memory_free_list[sizeof(vector)]); if (*q==0) *q = memory_allocate_block(sizeof(vector)); memory_elem_ptr p = *q; *q = p->next; return p; } void  operator delete(void* p){ memory_elem_ptr* q = &(memory_free_list[sizeof(vector)]); memory_elem_ptr(p)->next = *q; *q = memory_elem_ptr(p); } 

# 96 "/usr/local/lib/g++-include/LEDA/vector.h" 3

};


 
 
 




# 116 "/usr/local/lib/g++-include/LEDA/vector.h" 3


# 6 "ScnrScore.h" 2


# 1 "/usr/local/include/gdbm.h" 1 3
 

 





























extern "C" {


 






 





 
typedef struct {
	char *dptr;
	int   dsize;
      } datum;


 
typedef struct {int dummy[10];} *GDBM_FILE;


 

extern GDBM_FILE gdbm_open ();

extern void	 gdbm_close ();

extern datum	 gdbm_fetch ();

extern int	 gdbm_store ();

extern int	 gdbm_delete ();

extern datum	 gdbm_firstkey ();

extern datum	 gdbm_nextkey ();

extern int	 gdbm_reorganize ();


 
typedef enum {	GDBM_NO_ERROR,
		GDBM_MALLOC_ERROR,
		GDBM_BLOCK_SIZE_ERROR,
		GDBM_FILE_OPEN_ERROR,
		GDBM_FILE_WRITE_ERROR,
		GDBM_FILE_SEEK_ERROR,
		GDBM_FILE_READ_ERROR,
		GDBM_BAD_MAGIC_NUMBER,
		GDBM_EMPTY_DATABASE,
		GDBM_CANT_BE_READER,
	        GDBM_CANT_BE_WRITER,
		GDBM_READER_CANT_DELETE,
		GDBM_READER_CANT_STORE,
		GDBM_READER_CANT_REORGANIZE,
		GDBM_UNKNOWN_UPDATE,
		GDBM_ITEM_NOT_FOUND,
		GDBM_REORGANIZE_FAILED,
		GDBM_CANNOT_REPLACE,
		GDBM_ILLEGAL_DATA}
	gdbm_error;


}



# 8 "ScnrScore.h" 2



typedef char NameT[126 +1];

class ScnrScore
	{ 
public:      
	ScnrScore( int n );
	ScnrScore( const ScnrScore & );
	~ScnrScore();

	char *	Name() const					{ return name; }
	int		NoScenarios() const			{ return no_scnr; }     
	int		NoRuns() const					{ return no_runs; }
	int		NoSystems( int i ) const	{ return systems[i]; }
	double &	Probability( int n ) const	{ return (*scnr_prob)[n]; }

	char	  *Scenario( int i ) const		{ return scnr_name[i]; }
	char	  *Party( int n ) const			{ return pty_name[n]; }
                                          
	void		Name( char *s )					{ strcpy( name, s ); }
	void		Scenario( int i, char *s )		{ strcpy( scnr_name[i], s ); }
	void		Party( int i, char *s )			{ strcpy( pty_name[i], s ); }
	void		NoSystems( int i, int n )		{ systems[i] = n; }
	void		NoRuns( int n )					{ no_runs = n; }
	void		NoScenarios( int n );
  
	int 		operator==( ScnrScore & ) const;
	int 		operator!=( ScnrScore &a) const	{ return !(*this == a); }

	void		GdbmWrite( GDBM_FILE dbf );
	void		GdbmRead( GDBM_FILE dbf );

	void		Dump( ostream & );

private:
	NameT		name;
	int		no_scnr;
	int		no_runs;
	NameT		pty_name[2];
	int		systems[2];				 
	NameT  	*scnr_name;				 
	vector  *scnr_prob;

	unsigned name_length[2];		 

	ScnrScore();
	};



# 4 "ScnrScore.cc" 2

# 1 "debug.h" 1




# 1 "/usr/local/lib/g++-include/assert.h" 1 3


extern "C" {



 
# 1 "/usr/local/lib/g++-include/stdio.h" 1 3
 
 
















# 174 "/usr/local/lib/g++-include/stdio.h" 3

# 8 "/usr/local/lib/g++-include/assert.h" 2 3

# 1 "/usr/local/lib/gcc-lib/m68k-apollo-bsd/2.2.2/include/assert.h" 1 3
 








# 19 "/usr/local/lib/gcc-lib/m68k-apollo-bsd/2.2.2/include/assert.h" 3




 

extern "C" {
extern void __eprintf (const char *, const char *, int, const char *);
}











# 50 "/usr/local/lib/gcc-lib/m68k-apollo-bsd/2.2.2/include/assert.h" 3



# 9 "/usr/local/lib/g++-include/assert.h" 2 3




}

# 5 "debug.h" 2


static int dump_state = 1;








# 25 "debug.h"









                                           
extern int trace_flag;


# 5 "ScnrScore.cc" 2




ScnrScore::ScnrScore()
	{                              
	no_runs = 1;
	}                         

ScnrScore::ScnrScore( int n ) : ScnrScore()
	{
	no_scnr = n;
	scnr_name = new NameT( n );
	scnr_prob = new vector( n );
	}