CINTS2       := $(filter-out $(MODDIRS)/gcc4strm.%,$(CINTS2))

#

# lib/gcc4strm/Makefile

#

CP         = cp

MV	   = mv

CINTSYSDIR = ../..

SRCCPPIFC     = $(CINTSYSDIR)/src/gcc4strm.cxx

SRCCPPIFH     = $(CINTSYSDIR)/src/gcc4strm.h

CPPIFC     = gcc4strm.cxx

CPPIFH     = gcc4strm.h

CPPHEADER  = iostrm.h fstrm.h sstrm.h linkdef.h

#		stdiostr.h \

$(SRCCPPIFC) : $(CPPIFC)

#	cint ../snstream/length.cxx 255 $(CPPIFC) $(CPPIFH)

	$(MV) $(CPPIFC) $(SRCCPPIFC)		

	$(MV) $(CPPIFH) $(SRCCPPIFH)		

$(CPPIFC) : $(CPPHEADER)

	cint -Z0 -n$(CPPIFC) -NG__stream $(DLLSPEC) -D__MAKECINT__ -DG__MAKECINT -c-1 $(IPATH) $(MACRO) $(CPPHEADER) 

#	cint -Z0 -n$(CPPIFC) -NG__stream $(DLLSPEC) -D__MAKECINT__ -DG__MAKECINT -M0x10 -c-1 $(IPATH) $(MACRO) $(CPPHEADER) 

lib/gcc4strm/README

 lib/gcc4strm directory exists for creating iostream library linkage file

src/gcc4strm.cxx and src/gcc4strm.h for g++ 3.00 compiler. These files 

contain interface methods for iostream library. You can create those by 

doing 'make' under this directory. Usually nobody but only author should 

do this. User doesn't need to recognize this.

 Files in this directory are originally copied from lib/snstream/* and 

modified for gcc4strm.

 cbstream.cpp is based on template based stream library.

 Creating src/gcc4strm.cxx

 1) Just do 'make' in this directory. 

/* /% C++ %/ */

/***********************************************************************

 * cint (C/C++ interpreter)

 ************************************************************************

 * header file fstrm.h

 ************************************************************************

 * Description:

 *  Stub file for making iostream library

 ************************************************************************

 * Copyright(c) 2007  Masaharu Goto (cint@pcroot.cern.ch)

 *

 * For the licensing terms see the file COPYING

 *

 ************************************************************************/

#ifndef G__FSTREAM_H

#define G__FSTREAM_H

#ifndef __CINT__

#include <fstream>

using namespace std;

#else // __CINT__

#include "iostrm.h"

template<class charT, class traits>

class basic_filebuf : public basic_streambuf<charT, traits> {

  private:

    typedef basic_ios<charT, traits>              ios_type;

#ifndef __CINT__

    typedef traits::state_type           state_t; 

#endif

  public:

    typedef traits              traits_type;

    typedef charT		char_type;

    typedef traits::int_type    int_type;

    typedef traits::pos_type    pos_type;

    typedef traits::off_type    off_type;

    basic_filebuf();

#if !(G__GNUC>=3)

    basic_filebuf(int fd);

#endif

    virtual ~basic_filebuf();

    bool is_open() const;

#if !(G__GNUC>=3)

    basic_filebuf<charT, traits> *

      open(const char *s, ios_base::openmode, long protection = 0666 );

#else

    basic_filebuf<charT, traits> * open(const char *s, ios_base::openmode);

#endif

#if !(G__GNUC>=3)

    basic_filebuf<charT, traits> *open(int fd);

#endif

    basic_filebuf<charT, traits> *close();

  protected:

    virtual int      showmanyc();

    virtual int_type overflow(int_type c = traits::eof());

    virtual int_type pbackfail(int_type c = traits::eof());

    virtual int_type underflow();

    virtual basic_streambuf<charT,traits>* setbuf(char_type *s,streamsize n);

    virtual pos_type seekoff(off_type off,ios_base::seekdir way

                             ,ios_base::openmode which =

                                       ios_base::in | ios_base::out);

    virtual pos_type seekpos(pos_type sp

                             ,ios_base::openmode which =

                                       ios_base::in | ios_base::out);

    virtual int sync();

    virtual streamsize xsputn(const char_type *s, streamsize n);

#if (G__GNUC>=3)

 private:

    basic_filebuf& operator=(const basic_filebuf& x);

#endif

};

template<class charT, class traits>

class basic_ifstream : public basic_istream<charT, traits> {

  public:

    typedef basic_ios<charT, traits>          ios_type;

    typedef traits                            traits_type;

    typedef charT		       	      char_type;

    typedef traits::int_type                  int_type;

    typedef traits::pos_type                  pos_type;

    typedef traits::off_type                  off_type;

  public:

    basic_ifstream();

#if !(G__GNUC>=3)

    basic_ifstream(const char *s,ios_base::openmode mode = ios_base::in

		   ,long protection = 0666 );

    basic_ifstream(int fd);

    basic_ifstream(int fd, char_type *buf, int len);

#else

    basic_ifstream(const char *s,ios_base::openmode mode = ios_base::in);

#endif

    virtual ~basic_ifstream();

    basic_filebuf<charT, traits> *rdbuf() const;

    bool is_open();

#if !(G__GNUC>=3)

    void open(const char *s, ios_base::openmode mode = ios_base::in

              ,long protection = 0666 );

#else

    void open(const char *s, ios_base::openmode mode = ios_base::in);

#endif

    void close();

};

template<class charT, class traits>

class basic_ofstream : public basic_ostream<charT, traits> {

  public:

    typedef basic_ios<charT, traits>          ios_type;

    typedef traits                            traits_type;

    typedef charT		              char_type;

    typedef traits::int_type                  int_type;

    typedef traits::pos_type                  pos_type;

    typedef traits::off_type                  off_type;

  public:

    basic_ofstream();

#if !(G__GNUC>=3)

    basic_ofstream(const char *s, ios_base::openmode mode=ios_base::out

                            ,long protection = 0666 );

    basic_ofstream(int fd);

    basic_ofstream(int fd, char_type *buf, int len);

#else

    basic_ofstream(const char *s, ios_base::openmode mode=ios_base::out);

#endif

    virtual ~basic_ofstream();

    basic_filebuf<charT, traits> *rdbuf() const;

    bool is_open();

#if !(G__GNUC>=3)

    void open(const char *s,ios_base::openmode mode=ios_base::out

              ,long protection = 0666 );

#else

    void open(const char *s,ios_base::openmode mode=ios_base::out);

#endif

    void close();

 };

template<class charT, class traits>

class basic_fstream : public basic_iostream<charT, traits> {

 public:

    basic_fstream();

    basic_fstream(const char *s,ios_base::openmode mode);

    basic_filebuf<charT, traits> *rdbuf() const;

    bool is_open();

    void open(const char *s,ios_base::openmode mode);

    void close();

};

typedef basic_filebuf<char, char_traits<char> >         filebuf;

//typedef basic_filebuf<wchar_t, char_traits<wchar_t> >   wfilebuf;

typedef basic_ifstream<char, char_traits<char> >        ifstream;

//typedef basic_ifstream<wchar_t, char_traits<wchar_t> >  wifstream;

typedef basic_ofstream<char, char_traits<char> >        ofstream;

//typedef basic_ofstream<wchar_t, char_traits<wchar_t> >  wofstream;

typedef basic_fstream<char, char_traits<char> >        fstream;

//typedef basic_fstream<wchar_t, char_traits<wchar_t> >  wfstream;

#endif // __CINT__

#endif // G__FSTREAM_H

/* /% C++ %/ */

/***********************************************************************

 * cint (C/C++ interpreter)

 ************************************************************************

 * header file iostrm.h

 ************************************************************************

 * Description:

 *  Stub file for making iostream library for g++ 4.00

 ************************************************************************

 * Copyright(c) 2007   Masaharu Goto

 *

 * For the licensing terms see the file COPYING

 *

 ************************************************************************/

#ifndef G__IOSTREAM_H

#define G__IOSTREAM_H

#define G__TMPLTIOS

#define G__OSTREAMBODY

//#define G__OSTREAMMEMBERSTUB

#define G__OSTREAMGLOBALSTUB

#ifndef __CINT__

#include <iostream>

using namespace std;

//inline ostream& operator<< (ostream& ost,unsigned char c) 

//  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,short c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,unsigned short c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,int c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,unsigned int c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,long c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,unsigned long c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,float c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,double c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,long double c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< (ostream& ost,bool c) 

  {return(ost.operator<<(c));}

inline ostream& operator<< ( ostream& ost, void* p) 

  {return(ost.operator<<(p));}

//inline istream& operator>> ( istream& ist, unsigned char& p) 

//  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, short& p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, unsigned short& p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, int & p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, unsigned int& p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, long & p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, unsigned long& p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, float & p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, double & p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, bool& p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, long double & p) 

  {return(ist.operator>>(p));}

inline istream& operator>> ( istream& ist, void*& p) 

  {return(ist.operator>>(p));}

#ifndef G__OLDIMPLEMENTATION1635

#include <fstream>

/********************************************************************

 * static variables for iostream redirection

 ********************************************************************/

static ostream::__streambuf_type *G__store_cout;

static ostream::__streambuf_type *G__store_cerr;

static istream::__streambuf_type *G__store_cin;

static ofstream  *G__redirected_cout;

static ofstream  *G__redirected_cerr;

static ifstream  *G__redirected_cin;

/********************************************************************

 * G__redirectcout

 ********************************************************************/

extern "C" void G__unredirectcout() {

  if(G__store_cout) {

    cout.rdbuf(G__store_cout);

    G__store_cout = 0;

  }

  if(G__redirected_cout) {

    delete G__redirected_cout;

    G__redirected_cout = 0;

  }

}

/********************************************************************

 * G__redirectcout

 ********************************************************************/

extern "C" void G__redirectcout(const char* filename) {

  G__unredirectcout();

  G__redirected_cout = new ofstream(filename,ios_base::app);

  G__store_cout = cout.rdbuf(G__redirected_cout->rdbuf()) ;

}

/********************************************************************

 * G__redirectcerr

 ********************************************************************/

extern "C" void G__unredirectcerr() {

  if(G__store_cerr) {

    cerr.rdbuf(G__store_cerr);

    G__store_cerr = 0;

  }

  if(G__redirected_cerr) {

    delete G__redirected_cerr;

    G__redirected_cerr = 0;

  }

}

/********************************************************************

 * G__redirectcerr

 ********************************************************************/

extern "C" void G__redirectcerr(const char* filename) {

  G__unredirectcerr();

  G__redirected_cerr = new ofstream(filename,ios_base::app);

  G__store_cerr = cerr.rdbuf(G__redirected_cerr->rdbuf()) ;

}

/********************************************************************

 * G__redirectcin

 ********************************************************************/

extern "C" void G__unredirectcin() {

  if(G__store_cin) {

    cin.rdbuf(G__store_cin);

    G__store_cin = 0;

  }

  if(G__redirected_cin) {

    delete G__redirected_cin;

    G__redirected_cin = 0;

  }

}

/********************************************************************

 * G__redirectcin

 ********************************************************************/

extern "C" void G__redirectcin(const char* filename) {

  G__unredirectcin();

  G__redirected_cin = new ifstream(filename,ios_base::in);

  G__store_cin = cin.rdbuf(G__redirected_cin->rdbuf()) ;

}

#endif /* 1635 */

#else // __CINT__

#include <cstdio>

/********************************************************************

* streampos

*********************************************************************/

extern "C" {

  typedef struct {

    private:

     int __fill[6];

  } mbstate_t;

}

#ifdef G__THIS_DOES_NOT_WORK_WITH_CYGWIN_GCC3

class wstreampos { };

#endif

class streamoff { };

typedef long long streampos ;

typedef long long streamoff ;

typedef long long    SZ_T;       

typedef SZ_T         streamsize;

template<typename _StateT>

class fpos {

 public:

  fpos();

  fpos(const fpos&);

  fpos(long long);

  operator streamoff() const;

  fpos operator+(streamoff a) const;

  fpos operator-(streamoff a) const;

  streamoff operator-(const fpos& a) const;

  fpos& operator+=(streamoff a);

  fpos& operator-=(streamoff a);

  _StateT state() const;

  void state(_StateT a);

  //bool operator==(const fpos& a);

  //bool operator!=(const fpos& a);

  //FIXME: operator+= and operator-= are missing

  //bool operator>(const fpos& a);

  //friend bool operator<(const fpos& a,const fpos& b);

  //friend bool operator>(const fpos& a,const fpos& b);

  //friend bool operator<=(const fpos& a,const fpos& b);

  //friend bool operator<=(const fpos& a,const fpos& b);

};

template<typename _StateT>

inline bool operator==(const fpos<_StateT>& l, const fpos<_StateT>& r);

template<typename _StateT>

inline bool operator!=(const fpos<_StateT>& l, const fpos<_StateT>& r);

typedef fpos<mbstate_t> 		streampos;

/********************************************************************

* macro G__MANIP_SUPPORT must be defined to enable true manipulator

*********************************************************************/

#define G__MANIP_SUPPORT

class ios_base {

  public:

    typedef int      iostate;

    enum io_state {

	goodbit     = 0x00,   

	badbit      = 0x01,   

	eofbit      = 0x02,  

	failbit     = 0x04  

    };

    typedef int      openmode;

    enum open_mode {

	app         = 0x01,   

	binary      = 0x02,  

	in          = 0x04, 

	out         = 0x08,   

	trunc       = 0x10,                  

	ate         = 0x20 

    };

    typedef int      seekdir;

    enum seek_dir {

	beg         = 0x0,    

	cur         = 0x1,    

	end         = 0x2   

    };        

    typedef int      fmtflags;

    enum fmt_flags {

	boolalpha   = 0x0001,

	dec         = 0x0002,

	fixed       = 0x0004,

	hex         = 0x0008,

	internal    = 0x0010,

	left        = 0x0020,

	oct         = 0x0040,

	right       = 0x0080,

	scientific  = 0x0100,

	showbase    = 0x0200, 

	showpoint   = 0x0400, 

	showpos     = 0x0800, 

	skipws      = 0x1000, 

	unitbuf     = 0x2000, 

	uppercase   = 0x4000, 

	adjustfield = left | right | internal,

	basefield   = dec | oct | hex,

	floatfield  = scientific | fixed

    };

    enum event { 

	erase_event   = 0x0001,

	imbue_event   = 0x0002,

	copyfmt_event = 0x0004

    };

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

    void register_callback( event_callback fn, int index);

#ifdef G__SUNCC5

    enum EmptyCtor {emptyctor}; 

#endif

    class Init {

    public:

#if !(G__GNUC>=3)

	static int getinit_cnt_();

#endif

	Init();

#ifdef __MAKECINT__

       private:

#endif

	~Init();

    };

    inline fmtflags flags() const;

    inline fmtflags flags(fmtflags fmtfl);

    inline fmtflags setf(fmtflags fmtfl);

    inline fmtflags setf(fmtflags fmtfl, fmtflags mask);

    inline void unsetf(fmtflags mask);

#if !(G__GNUC>=3)

    ios_base& copyfmt(const ios_base& rhs);

#endif

    inline streamsize precision() const;

    inline streamsize precision(streamsize prec);

    inline streamsize width() const;

    inline streamsize width(streamsize wide);

    static int xalloc();

    long&  iword(int index);

    void*& pword(int index);

    //locale imbue(const locale& loc);

    //locale getloc() const ;

#if !(G__GNUC>=3)

    bool is_synch() ;

#endif

#ifdef G__SUNCC5

    static bool sync_with_stdio(bool sync = true);

#else

    bool sync_with_stdio(bool sync = true);

#endif

#ifdef G__SUNCC5

    virtual ~ios_base();    

#endif

  protected:

    ios_base();

#ifndef G__SUNCC5

    ~ios_base();    

#endif

#if (G__GNUC>=3)

  private:

    ios_base(const ios_base& x); 

    ios_base& operator=(const ios_base& x);

#endif

};

template<class charT, class traits>

class basic_ios : public ios_base { 

  public:

#if !(G__GNUC>=3)

    typedef basic_ios<charT,traits >           ios_type;

    typedef basic_streambuf<charT,traits >     streambuf_type; 

    typedef basic_ostream<charT,traits >       ostream_type;

#endif

    typedef traits::char_type      char_type;

    typedef traits                 traits_type;

    typedef traits::int_type       int_type;

    typedef traits::off_type       off_type;

    typedef traits::pos_type       pos_type;

    explicit basic_ios(basic_streambuf<charT, traits> *sb_arg);

    virtual ~basic_ios();

    char_type fill() const;        

    char_type fill(char_type ch);

    inline void exceptions(iostate excpt);

    inline iostate exceptions() const;

    inline void clear(iostate state = goodbit);

    inline void setstate(iostate state);

    inline iostate rdstate() const;

    inline operator void*() const;

    inline bool operator! () const;

    inline bool good() const;

    inline bool eof()  const;

    inline bool fail() const;

    inline bool bad()  const;

#if !(G__GNUC>=3)

    ios_type& copyfmt(const ios_type& rhs);

#else

    basic_ios& copyfmt(const basic_ios& rhs);

#endif

    inline basic_ostream<charT,traits> *tie() const;

    basic_ostream<charT,traits> *tie(basic_ostream<charT,traits> *tie_arg);

    inline basic_streambuf<charT,traits> *rdbuf() const;

    basic_streambuf<charT,traits> *rdbuf( basic_streambuf<charT,traits> *sb);

    //locale imbue(const locale& loc);

    inline char  narrow(charT, char) const;

    inline charT widen(char) const;

  protected:

    basic_ios();

    void init(basic_streambuf<charT, traits> *sb);

  private:

// #ifdef G__SUNCC5

    basic_ios(const basic_ios& );       //  not defined

    basic_ios& operator=(const basic_ios&);     //  not defined

// #endif

};

template<class charT, class traits>

class basic_streambuf {

  public:

    typedef charT		       	  char_type;

    typedef traits                        traits_type;

    typedef traits::int_type	          int_type;

    typedef traits::pos_type	          pos_type;

    typedef traits::off_type	          off_type;

    virtual ~basic_streambuf();

    //locale pubimbue( const locale& loc);

    //locale getloc() const; 

    inline  basic_streambuf<char_type, traits> *

	pubsetbuf(char_type *s, streamsize n);

    inline pos_type pubseekoff(off_type off, ios_base::seekdir way,

			       ios_base::openmode which =

			       ios_base::in | ios_base::out);

    inline pos_type pubseekpos(pos_type sp, ios_base::openmode which =

			       ios_base::in | ios_base::out);

    inline int pubsync( );

#if !(G__GNUC>=3)

    inline ios_base::openmode which_open_mode();

#endif

    inline streamsize   in_avail();

    inline int_type snextc();

    inline int_type sbumpc();

    inline int_type sgetc();

    inline streamsize sgetn(char_type *s, streamsize n);

    inline int_type sputbackc(char_type c);

    inline int_type sungetc();

    inline int_type sputc(char_type c);

    inline streamsize sputn(const char_type *s, streamsize n);

  protected:

    basic_streambuf();

#if (G__GNUC>=3)

  private:

    basic_streambuf(const basic_streambuf& x);

    basic_streambuf& operator=(const basic_streambuf& x);

#endif

};

template<class charT, class traits>

class basic_istream : virtual public basic_ios<charT, traits> {

  public:

    typedef basic_istream<charT, traits>             __istream_type;

    typedef basic_ios<charT, traits>                 __ios_type;

    typedef basic_streambuf<charT, traits>           __streambuf_type;

    typedef traits                      traits_type;

    typedef charT		      	char_type;

    typedef traits::int_type   int_type;

    typedef traits::pos_type   pos_type;

    typedef traits::off_type   off_type;

    explicit basic_istream(basic_streambuf<charT, traits> *sb);

    virtual ~basic_istream();

    class sentry {

    public:

	inline sentry(basic_istream<charT,traits>& stream,bool noskipws = 0);

#ifdef __MAKECINT__

       private:

	~sentry() {}

       public:

#else

	~sentry() {}

#endif

	operator bool () { return ok_; }

    };

    //__istream_type& operator>>(__istream_type& (*pf)(__istream_type&));

    //__istream_type& operator>>(ios_base& (*pf)(ios_base&));

    //__istream_type& operator>>(__ios_type& (*pf)(__ios_type&));

#ifndef __CINT__

    __istream_type& operator>>(bool& n);

    __istream_type& operator>>(short& n);

    __istream_type& operator>>(unsigned short& n);

    __istream_type& operator>>(int& n);

    __istream_type& operator>>(unsigned int& n);

    __istream_type& operator>>(long& n);

    __istream_type& operator>>(unsigned long& n);

    __istream_type& operator>>(float& f);

    __istream_type& operator>>(double& f);

    __istream_type& operator>>(long double& f);

#if !(G__GNUC>=3)

    __istream_type& operator>>(__streambuf_type *sb);

#endif

    __istream_type& operator>>(void*& p);

#endif

#if !(G__GNUC>=3)

    __istream_type& operator>>(__streambuf_type& sb);

#endif

    int_type get();

    __istream_type& get(char_type *s, streamsize n, char_type delim);

    __istream_type& get(char_type *s, streamsize n);

    __istream_type& get(char_type& c);

    __istream_type& get(__streambuf_type& sb, char_type delim);

    __istream_type& get(__streambuf_type& sb);

    __istream_type& getline(char_type *s, streamsize n, char_type delim);

    __istream_type& getline(char_type *s, streamsize n);

    __istream_type& ignore(streamsize n , int_type delim );

    __istream_type& ignore(streamsize n =1 );

    //__istream_type& ignore(streamsize n = 1, int_type delim = traits::eof());

    __istream_type& read(char_type *s, streamsize n);

    streamsize readsome(char_type *s, streamsize n);

    int peek();

    pos_type tellg();

    __istream_type& seekg(pos_type pos);

    int sync();

//#ifndef __CINT__

    __istream_type& seekg(off_type, ios_base::seekdir);

//#endif

    __istream_type& putback(char_type c);

    __istream_type& unget();

    streamsize gcount() const;

  protected:

    basic_istream( );

};

template<class charT, class traits>

class basic_ostream : virtual public basic_ios<charT, traits> {

  public:

    typedef basic_ostream<charT, traits>           __ostream_type;

    typedef basic_ios<charT, traits>               __ios_type;

    typedef traits                                 traits_type;

    typedef charT                                  char_type;

    typedef traits::int_type              int_type;

    typedef traits::pos_type              pos_type;

    typedef traits::off_type              off_type;

    explicit basic_ostream(basic_streambuf<charT, traits> *sb);

    virtual ~basic_ostream();

    class sentry {

    public:

      inline explicit sentry(basic_ostream<charT,traits>& stream);

#ifdef __MAKECINT__

       private:

	~sentry() {}

       public:

#else

       ~sentry() ;

#endif

      operator bool () ;

    private:

//#ifdef G__SUNCC5

      sentry(const sentry&); //   not defined

      sentry& operator=(const sentry&); //   not defined

//#endif

    };

    //__ostream_type& operator<<(__ostream_type& (*pf)(__ostream_type&));

    //__ostream_type& operator<<(ios_base& (*pf)(ios_base&));

    //__ostream_type& operator<<(__ios_type& (*pf)(__ios_type&));

#ifndef __CINT__

    __ostream_type& operator<<(short n);

    __ostream_type& operator<<(unsigned short n);

    __ostream_type& operator<<(int n);

    __ostream_type& operator<<(unsigned int n);

    __ostream_type& operator<<(long n);

    __ostream_type& operator<<(unsigned long n);

    __ostream_type& operator<<(float f);

    __ostream_type& operator<<(double f);

    __ostream_type& operator<<(long double f); 

    __ostream_type& operator<<(bool n);

    __ostream_type& operator<<(basic_streambuf<char_type, traits> *sb);

    __ostream_type& operator<<(void *p);

#endif

    //__ostream_type& operator<<(basic_streambuf<char_type, traits>& sb);

    __ostream_type& put(char_type c);

    __ostream_type& write(const char_type *s, streamsize n);

    __ostream_type& flush();

    __ostream_type& seekp(pos_type pos);

    __ostream_type& seekp(off_type , ios_base::seekdir );

    pos_type tellp();

  protected:

    basic_ostream();

};

template<class charT, class traits>

class basic_iostream 

 : public basic_istream<charT,traits>,public basic_ostream<charT,traits> 

{

public:

  explicit basic_iostream(basic_streambuf<charT, traits> *sb);

  virtual ~basic_iostream();

protected:

  explicit basic_iostream();

};

typedef int INT_T;

template<class charT>

struct char_traits {

    typedef charT                     char_type;

    typedef INT_T                     int_type;

    typedef mbstate_t                 state_type;

    typedef fpos<state_type>         pos_type;

    typedef wstreamoff               off_type;

    static void assign (char_type& c1, const char_type& c2)   ;

    static char_type to_char_type(const int_type& c);

    static int_type to_int_type(const char_type& c);

    static bool     eq(const char_type& c1,const char_type& c2);

    static bool lt (const char_type& c1, const char_type& c2) ;

    static int compare (const char_type* s1, const char_type* s2, size_t n);

    static bool     eq_int_type(const int_type& c1,const int_type& c2);

    static int_type             eof();

    static int_type             not_eof(const int_type& c);

    static size_t               length(const char_type *s);

    static const char_type* find (const char_type* s,int n,const char_type& a);

    static char_type  *copy(char_type *dst,const char_type *src, size_t n);

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

    static char_type* assign (char_type* s, size_t n, const char_type a);

};

struct char_traits<char> {

    typedef char                      char_type;

    typedef int                       int_type;

#ifdef __CINT__

    typedef streamoff                 off_type; 

    typedef streampos                 pos_type;

    typedef mbstate_t                 state_type;

#endif 

    static void assign (char_type& c1, const char_type& c2)   ;

    static char_type         to_char_type(const int_type& c);

    static int_type          to_int_type(const char_type& c);

    static bool              eq(const char_type& c1,const char_type& c2);

    static bool lt (const char_type& c1, const char_type& c2) ;

    static int compare (const char_type* s1, const char_type* s2, size_t n);

    static const char_type* find (const char_type* s,int n,const char_type& a);

    static bool         eq_int_type(const int_type& c1,const int_type& c2);

    static int_type          eof();

    static int_type          not_eof(const int_type& c);

    static size_t            length(const char_type *s);

    static char_type  *copy(char_type *dst,const char_type *src, size_t n);

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

    static char_type* assign (char_type* s, size_t n, const char_type a);

};

//typedef basic_istream<char> >                   istream;

typedef basic_istream<char, char_traits<char> >   istream;

//typedef basic_ostream<char>                     ostream;

typedef basic_ostream<char, char_traits<char> >   ostream;

typedef basic_streambuf<char,char_traits<char> > streambuf;

extern istream cin ;

extern ostream cout ;

extern ostream cerr ;

extern ostream clog ;

#ifndef G__OLDIMPLEMENTATION1938

ios_base&	dec(ios_base&) ; 

ios_base&	hex(ios_base&) ;

ios_base&	oct(ios_base&) ; 

ios_base&       fixed(ios_base&);

ios_base&       scientific(ios_base&);

ios_base&       right(ios_base&);

ios_base&       left(ios_base&);

ios_base&       internal(ios_base&);

ios_base&       nouppercase(ios_base&);

ios_base&       uppercase(ios_base&);

ios_base&       noskipws(ios_base&);

ios_base&       skipws(ios_base&);

ios_base&       noshowpos(ios_base&);

ios_base&       showpos(ios_base&);

ios_base&       noshowpoint(ios_base&);

ios_base&       showpoint(ios_base&);

ios_base&       noshowbase(ios_base&);

ios_base&       showbase(ios_base&);

ios_base&       noboolalpha(ios_base&);

ios_base&       boolalpha(ios_base&);

#endif

istream&	ws(istream&) ;

ostream&	endl(ostream& i) ;

ostream&	ends(ostream& i) ;

ostream&	flush(ostream&) ;

ostream& operator<< ( ostream&, char );

ostream& operator<< ( ostream&, char* );

ostream& operator<< ( ostream&, void* );

ostream& operator<< ( ostream&, unsigned char );

ostream& operator<< ( ostream&, short );

ostream& operator<< ( ostream&, unsigned short );

ostream& operator<< ( ostream&, int );

ostream& operator<< ( ostream&, unsigned int );

ostream& operator<< ( ostream&, long );

ostream& operator<< ( ostream&, unsigned long);

ostream& operator<< ( ostream&, float );

ostream& operator<< ( ostream&, double );

//ostream& operator<< ( ostream&, long double );

ostream& operator<< ( ostream&, bool );

//ostream& operator<< (ostream&,const streampos&);

istream& operator>> ( istream&, char& );

istream& operator>> ( istream&, unsigned char& );

istream& operator>> ( istream&, short& );

istream& operator>> ( istream&, unsigned short& );

istream& operator>> ( istream&, int& );

istream& operator>> ( istream&, unsigned int& );

istream& operator>> ( istream&, long& );

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

istream& operator>> ( istream&, float& );

istream& operator>> ( istream&, double& );

//istream& operator>> ( istream&, long double& );

istream& operator>> ( istream&, bool& );

istream& operator>> ( istream&, char* );

istream& operator>> ( istream&, void*& );

#endif // __CINT__

#endif // G__IOSTREAM_H

/* -*- C++ -*- */

/*************************************************************************

 * Copyright(c) 2007  Masaharu Goto (cint@pcroot.cern.ch)

 *

 * For the licensing terms see the file COPYING

 *

 ************************************************************************/

#ifdef __MAKECINT__

#pragma link off class allocator<char>;

#pragma link off class allocator<wchar_t>;

#pragma link MACRO function char_traits<char>::assign(char_type*,size_t,const char_type);

#endif

/* /% C++ %/ */

/***********************************************************************

 * cint (C/C++ interpreter)

 ************************************************************************

 * header file sstrm.h

 ************************************************************************

 * Description:

 *  Stub file for making iostream library

 ************************************************************************

 * Copyright(c) 2007 Masaharu Goto

 *

 * For the licensing terms see the file COPYING

 *

 ************************************************************************/

#ifndef G__SSTREAM_H

#define G__SSTREAM_H

#ifndef __CINT__

#include <sstream>

using namespace std;

#else // __CINT__

#if !(G__GNUC>=3)

#error This header must be processed with a Cint compiled with gcc3.x

#endif

#include <string>

//#include <memory>

class allocator<char>;

class allocator<wchar_t>;

#include "iostrm.h"

template<class charT, class traits, class Allocator>

class basic_stringbuf : public basic_streambuf<charT, traits>

{

 public:

  typedef charT                                    char_type;

  typedef traits::int_type               int_type;

  typedef traits::pos_type               pos_type;

  typedef traits::off_type               off_type;

  typedef traits                                   traits_type;

  typedef basic_ios<charT, traits>                 ios_type;

#ifdef __CINT__

#if 0 && !(G__GNUC>=3)

  typedef string  string_type;

#else

  typedef string  __string_type;

  //typedef basic_string<charT, traits, Allocator >  __string_type;

#endif

#else

  typedef basic_string<charT, traits, Allocator >  string_type;

#endif

  explicit basic_stringbuf(ios_base::openmode which = 

			   ios_base::in | ios_base::out );

  explicit basic_stringbuf(const __string_type& str,

			   ios_base::openmode which = 

			   ios_base::in | ios_base::out );

  virtual ~basic_stringbuf();

  __string_type str() const;

  void str(const __string_type& str_arg);

 protected:

  virtual int_type overflow(int_type c = traits::eof());

  virtual int_type pbackfail(int_type c = traits::eof());

  virtual int_type underflow();

  virtual pos_type seekoff(off_type off, ios_base::seekdir way,

			   ios_base::openmode which =

			   ios_base::in | ios_base::out);

  virtual pos_type seekpos(pos_type sp,

			   ios_base::openmode which =

			   ios_base::in | ios_base::out);

  virtual basic_streambuf<charT,traits>* setbuf(char_type* s, streamsize n);

  virtual streamsize xsputn(const char_type *s, streamsize n);

#if (G__GNUC>=3)

 private:

  basic_stringbuf& operator=(const basic_stringbuf& x);

#endif

};

template<class charT, class traits, class Allocator>

class basic_istringstream : public basic_istream<charT, traits>

{

 public:

  typedef charT                                           char_type;

  typedef traits::int_type                      int_type;

  typedef traits::pos_type                      pos_type;

  typedef traits::off_type                      off_type;

  typedef traits                                          traits_type;

  typedef basic_stringbuf<charT, traits, Allocator>       sb_type;

  typedef basic_ios<charT, traits>                        ios_type;

#ifdef __CINT__

#if 0 && !(G__GNUC>=3)

  typedef string         string_type;

#else

  typedef string         __string_type;

#endif

#else

  typedef basic_string<charT, traits, Allocator >         string_type;

#endif

  explicit basic_istringstream(ios_base::openmode which = ios_base::in);

  explicit basic_istringstream(const __string_type& str,

			       ios_base::openmode which = ios_base::in);

#ifdef __CINT__

  explicit basic_istringstream(const char *str,

			       ios_base::openmode which = ios_base::in);

#endif

  virtual ~basic_istringstream();

  basic_stringbuf<charT, traits, Allocator> *rdbuf() const;

  __string_type str() const;

  void str(const __string_type& str);

};

template<class charT, class traits, class Allocator>

class basic_ostringstream : public basic_ostream<charT, traits>

{

 public:

  typedef charT                                             char_type;

  typedef traits::int_type                        int_type;

  typedef traits::pos_type                        pos_type;

  typedef traits::off_type                        off_type;

  typedef traits                                            traits_type;

  typedef basic_stringbuf<charT, traits, Allocator>         sb_type;

  typedef basic_ios<charT, traits>                          ios_type;

#ifdef __CINT__

  typedef string          __string_type;

#else

  typedef basic_string<charT, traits, Allocator>            string_type;

#endif

  explicit basic_ostringstream(ios_base::openmode which = ios_base::out);

  explicit basic_ostringstream(const __string_type& str,

			       ios_base::openmode which = ios_base::out);

  virtual ~basic_ostringstream();

  basic_stringbuf<charT, traits, Allocator> *rdbuf() const;

  __string_type str() const;

  void str(const __string_type& str);

};

template<class charT, class traits, class Allocator>

class basic_stringstream : public basic_iostream<charT, traits>

{

 public:

  typedef charT                                             char_type;

  typedef traits::int_type                        int_type;

  typedef traits::pos_type                        pos_type;

  typedef traits::off_type                        off_type;

  typedef traits                                            traits_type;

  typedef basic_stringbuf<charT, traits, Allocator>         sb_type;

  typedef basic_ios<charT, traits>                          ios_type;

#ifdef __CINT__

  typedef string            __string_type;

#else

  typedef basic_string<charT, traits, Allocator>            string_type;

#endif

  explicit basic_stringstream(ios_base::openmode which = ios_base::out | 

			      ios_base::in);

  explicit basic_stringstream(const __string_type& str,

			      ios_base::openmode which = 

			      ios_base::out | ios_base::in);

  virtual ~basic_stringstream();

  basic_stringbuf<charT, traits, Allocator> *rdbuf() const;

  __string_type str() const;

  void str(const __string_type& str);

};

//typedef basic_stringbuf<char>    stringbuf;

typedef basic_stringbuf<char,char_traits<char>,allocator<char> > stringbuf;

//typedef basic_stringbuf<wchar_t>           wstringbuf;

//typedef basic_stringbuf<wchar_t,char_traits<wchar_t>,allocator<wchar_t> > wstringbuf;

//typedef basic_istringstream<char>      istringstream;

typedef basic_istringstream<char,char_traits<char>,allocator<char> > istringstream;

//typedef basic_istringstream<wchar_t>       wistringstream;

//typedef basic_istringstream<wchar_t,char_traits<wchar_t>,allocator<wchar_t> > wistringstream;

//typedef basic_ostringstream<char>    ostringstream;

typedef basic_ostringstream<char,char_traits<char>,allocator<char> > ostringstream;

//typedef basic_ostringstream<wchar_t>    wostringstream;

//typedef basic_ostringstream<wchar_t,char_traits<wchar_t>,allocator<wchar_t> > wostringstream;

//typedef basic_stringstream<char>   stringstream;

typedef basic_stringstream<char,char_traits<char>,allocator<char> > stringstream;

//typedef basic_stringstream<wchar_t>  wstringstream;

//typedef basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstringstream;

#endif // __CINT__

#endif // G__SSTREAM_H

/********************************************************

* gcc4strm.cxx

* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED

*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().

*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.

********************************************************/

#include "gcc4strm.h"

#ifdef G__MEMTEST

#undef malloc

#undef free

#endif

extern "C" void G__cpp_reset_tagtableG__stream();

extern "C" void G__set_cpp_environmentG__stream() {

  G__add_compiledheader("iostrm.h");

  G__add_compiledheader("fstrm.h");

  G__add_compiledheader("sstrm.h");

  G__add_compiledheader("linkdef.h");

  G__cpp_reset_tagtableG__stream();

}

#include <new>

extern "C" int G__cpp_dllrevG__stream() { return(30051515); }

/*********************************************************

* Member function Interface Method

*********************************************************/

/* mbstate_t */

// automatic default constructor

static int G__G__stream_1_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   mbstate_t *p;

   long gvp = G__getgvp();

   int n = G__getaryconstruct();

   if (n) {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new mbstate_t[n];

     } else {

       p = new((void*) gvp) mbstate_t[n];

     }

   } else {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new mbstate_t;

     } else {

       p = new((void*) gvp) mbstate_t;

     }

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_mbstate_t);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic copy constructor

static int G__G__stream_1_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   mbstate_t* p;

   void* tmp = (void*) G__int(libp->para[0]);

   p = new mbstate_t(*(mbstate_t*) tmp);

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_mbstate_t);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic destructor

typedef mbstate_t G__Tmbstate_t;

static int G__G__stream_1_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   long gvp = G__getgvp();

   long soff = G__getstructoffset();

   int n = G__getaryconstruct();

   //

   //has_a_delete: 0

   //has_own_delete1arg: 0

   //has_own_delete2arg: 0

   //

   if (!soff) {

     return(1);

   }

   if (n) {

     if (gvp == G__PVOID) {

       delete[] (mbstate_t*) soff;

     } else {

       G__setgvp(G__PVOID);

       for (int i = n - 1; i >= 0; --i) {

         ((mbstate_t*) (soff+(sizeof(mbstate_t)*i)))->~G__Tmbstate_t();

       }

       G__setgvp(gvp);

     }

   } else {

     if (gvp == G__PVOID) {

       delete (mbstate_t*) soff;

     } else {

       G__setgvp(G__PVOID);

       ((mbstate_t*) (soff))->~G__Tmbstate_t();

       G__setgvp(gvp);

     }

   }

   G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic assignment operator

static int G__G__stream_1_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   mbstate_t* dest = (mbstate_t*) G__getstructoffset();

   *dest = *(mbstate_t*) libp->para[0].ref;

   const mbstate_t& obj = *dest;

   result7->ref = (long) (&obj);

   result7->obj.i = (long) (&obj);

   return(1 || funcname || hash || result7 || libp) ;

}

/* streamoff */

// automatic default constructor

static int G__G__stream_2_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   streamoff *p;

   long gvp = G__getgvp();

   int n = G__getaryconstruct();

   if (n) {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new streamoff[n];

     } else {

       p = new((void*) gvp) streamoff[n];

     }

   } else {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new streamoff;

     } else {

       p = new((void*) gvp) streamoff;

     }

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_streamoff);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic copy constructor

static int G__G__stream_2_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   streamoff* p;

   void* tmp = (void*) G__int(libp->para[0]);

   p = new streamoff(*(streamoff*) tmp);

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_streamoff);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic destructor

typedef streamoff G__Tstreamoff;

static int G__G__stream_2_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   long gvp = G__getgvp();

   long soff = G__getstructoffset();

   int n = G__getaryconstruct();

   //

   //has_a_delete: 0

   //has_own_delete1arg: 0

   //has_own_delete2arg: 0

   //

   if (!soff) {

     return(1);

   }

   if (n) {

     if (gvp == G__PVOID) {

       delete[] (streamoff*) soff;

     } else {

       G__setgvp(G__PVOID);

       for (int i = n - 1; i >= 0; --i) {

         ((streamoff*) (soff+(sizeof(streamoff)*i)))->~G__Tstreamoff();

       }

       G__setgvp(gvp);

     }

   } else {

     if (gvp == G__PVOID) {

       delete (streamoff*) soff;

     } else {

       G__setgvp(G__PVOID);

       ((streamoff*) (soff))->~G__Tstreamoff();

       G__setgvp(gvp);

     }

   }

   G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic assignment operator

static int G__G__stream_2_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   streamoff* dest = (streamoff*) G__getstructoffset();

   const streamoff& obj = *dest;

   result7->ref = (long) (&obj);

   result7->obj.i = (long) (&obj);

   return(1 || funcname || hash || result7 || libp) ;

}

/* fpos<mbstate_t> */

static int G__G__stream_3_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   fpos<mbstate_t>* p = NULL;

   long gvp = G__getgvp();

   int n = G__getaryconstruct();

   if (n) {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new fpos<mbstate_t>[n];

     } else {

       p = new((void*) gvp) fpos<mbstate_t>[n];

     }

   } else {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new fpos<mbstate_t>;

     } else {

       p = new((void*) gvp) fpos<mbstate_t>;

     }

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   fpos<mbstate_t>* p = NULL;

   long gvp = G__getgvp();

   //m: 1

   if ((gvp == G__PVOID) || (gvp == 0)) {

     p = new fpos<mbstate_t>(*(fpos<mbstate_t>*) libp->para[0].ref);

   } else {

     p = new((void*) gvp) fpos<mbstate_t>(*(fpos<mbstate_t>*) libp->para[0].ref);

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   fpos<mbstate_t>* p = NULL;

   long gvp = G__getgvp();

   //m: 1

   if ((gvp == G__PVOID) || (gvp == 0)) {

     p = new fpos<mbstate_t>((long long) G__Longlong(libp->para[0]));

   } else {

     p = new((void*) gvp) fpos<mbstate_t>((long long) G__Longlong(libp->para[0]));

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_fposlEmbstate_tgR);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letLonglong(result7, 110, (G__int64) ((const fpos<mbstate_t>*) G__getstructoffset())->operator streamoff());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const fpos<mbstate_t>* pobj;

         const fpos<mbstate_t> xobj = ((const fpos<mbstate_t>*) G__getstructoffset())->operator+((streamoff) G__Longlong(libp->para[0]));

         pobj = new fpos<mbstate_t>(xobj);

         result7->obj.i = (long) ((void*) pobj);

         result7->ref = result7->obj.i;

         G__store_tempobject(*result7);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const fpos<mbstate_t>* pobj;

         const fpos<mbstate_t> xobj = ((const fpos<mbstate_t>*) G__getstructoffset())->operator-((streamoff) G__Longlong(libp->para[0]));

         pobj = new fpos<mbstate_t>(xobj);

         result7->obj.i = (long) ((void*) pobj);

         result7->ref = result7->obj.i;

         G__store_tempobject(*result7);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letLonglong(result7, 110, (G__int64) ((const fpos<mbstate_t>*) G__getstructoffset())->operator-(*(fpos<mbstate_t>*) libp->para[0].ref));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const fpos<mbstate_t>& obj = ((fpos<mbstate_t>*) G__getstructoffset())->operator+=((streamoff) G__Longlong(libp->para[0]));

         result7->ref = (long) (&obj);

         result7->obj.i = (long) (&obj);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const fpos<mbstate_t>& obj = ((fpos<mbstate_t>*) G__getstructoffset())->operator-=((streamoff) G__Longlong(libp->para[0]));

         result7->ref = (long) (&obj);

         result7->obj.i = (long) (&obj);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const mbstate_t* pobj;

         const mbstate_t xobj = ((const fpos<mbstate_t>*) G__getstructoffset())->state();

         pobj = new mbstate_t(xobj);

         result7->obj.i = (long) ((void*) pobj);

         result7->ref = result7->obj.i;

         G__store_tempobject(*result7);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_3_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      ((fpos<mbstate_t>*) G__getstructoffset())->state(*((mbstate_t*) G__int(libp->para[0])));

      G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic destructor

typedef fpos<mbstate_t> G__TfposlEmbstate_tgR;

static int G__G__stream_3_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   long gvp = G__getgvp();

   long soff = G__getstructoffset();

   int n = G__getaryconstruct();

   //

   //has_a_delete: 0

   //has_own_delete1arg: 0

   //has_own_delete2arg: 0

   //

   if (!soff) {

     return(1);

   }

   if (n) {

     if (gvp == G__PVOID) {

       delete[] (fpos<mbstate_t>*) soff;

     } else {

       G__setgvp(G__PVOID);

       for (int i = n - 1; i >= 0; --i) {

         ((fpos<mbstate_t>*) (soff+(sizeof(fpos<mbstate_t>)*i)))->~G__TfposlEmbstate_tgR();

       }

       G__setgvp(gvp);

     }

   } else {

     if (gvp == G__PVOID) {

       delete (fpos<mbstate_t>*) soff;

     } else {

       G__setgvp(G__PVOID);

       ((fpos<mbstate_t>*) (soff))->~G__TfposlEmbstate_tgR();

       G__setgvp(gvp);

     }

   }

   G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic assignment operator

static int G__G__stream_3_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   fpos<mbstate_t>* dest = (fpos<mbstate_t>*) G__getstructoffset();

   const fpos<mbstate_t>& obj = *dest;

   result7->ref = (long) (&obj);

   result7->obj.i = (long) (&obj);

   return(1 || funcname || hash || result7 || libp) ;

}

/* ios_base */

static int G__G__stream_4_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      ((ios_base*) G__getstructoffset())->register_callback((ios_base::event_callback) G__int(libp->para[0]), (int) G__int(libp->para[1]));

      G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) ((const ios_base*) G__getstructoffset())->flags());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) ((ios_base*) G__getstructoffset())->flags((ios_base::fmtflags) G__int(libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) ((ios_base*) G__getstructoffset())->setf((ios_base::fmtflags) G__int(libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) ((ios_base*) G__getstructoffset())->setf((ios_base::fmtflags) G__int(libp->para[0]), (ios_base::fmtflags) G__int(libp->para[1])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      ((ios_base*) G__getstructoffset())->unsetf((ios_base::fmtflags) G__int(libp->para[0]));

      G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letLonglong(result7, 110, (G__int64) ((const ios_base*) G__getstructoffset())->precision());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letLonglong(result7, 110, (G__int64) ((ios_base*) G__getstructoffset())->precision((streamsize) G__Longlong(libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letLonglong(result7, 110, (G__int64) ((const ios_base*) G__getstructoffset())->width());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letLonglong(result7, 110, (G__int64) ((ios_base*) G__getstructoffset())->width((streamsize) G__Longlong(libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) ios_base::xalloc());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const long& obj = ((ios_base*) G__getstructoffset())->iword((int) G__int(libp->para[0]));

         result7->ref = (long) (&obj);

         G__letint(result7, result7->type, (long)obj);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         void*& obj = ((ios_base*) G__getstructoffset())->pword((int) G__int(libp->para[0]));

         result7->ref = (long) (&obj);

         G__letint(result7, result7->type, (long)obj);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_4_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   switch (libp->paran) {

   case 1:

      G__letint(result7, 103, (long) ((ios_base*) G__getstructoffset())->sync_with_stdio((bool) G__int(libp->para[0])));

      break;

   case 0:

      G__letint(result7, 103, (long) ((ios_base*) G__getstructoffset())->sync_with_stdio());

      break;

   }

   return(1 || funcname || hash || result7 || libp) ;

}

/* ios_base::Init */

static int G__G__stream_10_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   ios_base::Init* p = NULL;

   long gvp = G__getgvp();

   int n = G__getaryconstruct();

   if (n) {

     p = 0;

     G__genericerror("Error: Array construction with private/protected destructor is illegal");

   } else {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new ios_base::Init;

     } else {

       p = new((void*) gvp) ios_base::Init;

     }

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic copy constructor

static int G__G__stream_10_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   ios_base::Init* p;

   void* tmp = (void*) G__int(libp->para[0]);

   p = new ios_base::Init(*(ios_base::Init*) tmp);

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_ios_basecLcLInit);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic assignment operator

static int G__G__stream_10_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   ios_base::Init* dest = (ios_base::Init*) G__getstructoffset();

   const ios_base::Init& obj = *dest;

   result7->ref = (long) (&obj);

   result7->obj.i = (long) (&obj);

   return(1 || funcname || hash || result7 || libp) ;

}

/* char_traits<char> */

static int G__G__stream_11_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      char_traits<char>::assign(*(char_traits<char>::char_type*) G__Charref(&libp->para[0]), *(char_traits<char>::char_type*) G__Charref(&libp->para[1]));

      G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 99, (long) char_traits<char>::to_char_type(*(char_traits<char>::int_type*) G__Intref(&libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) char_traits<char>::to_int_type(*(char_traits<char>::char_type*) G__Charref(&libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 103, (long) char_traits<char>::eq(*(char_traits<char>::char_type*) G__Charref(&libp->para[0]), *(char_traits<char>::char_type*) G__Charref(&libp->para[1])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 103, (long) char_traits<char>::lt(*(char_traits<char>::char_type*) G__Charref(&libp->para[0]), *(char_traits<char>::char_type*) G__Charref(&libp->para[1])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) char_traits<char>::compare((const char_traits<char>::char_type*) G__int(libp->para[0]), (const char_traits<char>::char_type*) G__int(libp->para[1])

, (size_t) G__int(libp->para[2])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 67, (long) char_traits<char>::find((const char_traits<char>::char_type*) G__int(libp->para[0]), (int) G__int(libp->para[1])

, *(char_traits<char>::char_type*) G__Charref(&libp->para[2])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 103, (long) char_traits<char>::eq_int_type(*(char_traits<char>::int_type*) G__Intref(&libp->para[0]), *(char_traits<char>::int_type*) G__Intref(&libp->para[1])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) char_traits<char>::eof());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) char_traits<char>::not_eof(*(char_traits<char>::int_type*) G__Intref(&libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 107, (long) char_traits<char>::length((const char_traits<char>::char_type*) G__int(libp->para[0])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 67, (long) char_traits<char>::copy((char_traits<char>::char_type*) G__int(libp->para[0]), (const char_traits<char>::char_type*) G__int(libp->para[1])

, (size_t) G__int(libp->para[2])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 67, (long) char_traits<char>::move((char_traits<char>::char_type*) G__int(libp->para[0]), (const char_traits<char>::char_type*) G__int(libp->para[1])

, (size_t) G__int(libp->para[2])));

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_11_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 67, (long) char_traits<char>::assign((char_traits<char>::char_type*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])

, (const char_traits<char>::char_type) G__int(libp->para[2])));

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic default constructor

static int G__G__stream_11_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   char_traits<char> *p;

   long gvp = G__getgvp();

   int n = G__getaryconstruct();

   if (n) {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new char_traits<char>[n];

     } else {

       p = new((void*) gvp) char_traits<char>[n];

     }

   } else {

     if ((gvp == G__PVOID) || (gvp == 0)) {

       p = new char_traits<char>;

     } else {

       p = new((void*) gvp) char_traits<char>;

     }

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic copy constructor

static int G__G__stream_11_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   char_traits<char>* p;

   void* tmp = (void*) G__int(libp->para[0]);

   p = new char_traits<char>(*(char_traits<char>*) tmp);

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_char_traitslEchargR);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic destructor

typedef char_traits<char> G__Tchar_traitslEchargR;

static int G__G__stream_11_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   long gvp = G__getgvp();

   long soff = G__getstructoffset();

   int n = G__getaryconstruct();

   //

   //has_a_delete: 0

   //has_own_delete1arg: 0

   //has_own_delete2arg: 0

   //

   if (!soff) {

     return(1);

   }

   if (n) {

     if (gvp == G__PVOID) {

       delete[] (char_traits<char>*) soff;

     } else {

       G__setgvp(G__PVOID);

       for (int i = n - 1; i >= 0; --i) {

         ((char_traits<char>*) (soff+(sizeof(char_traits<char>)*i)))->~G__Tchar_traitslEchargR();

       }

       G__setgvp(gvp);

     }

   } else {

     if (gvp == G__PVOID) {

       delete (char_traits<char>*) soff;

     } else {

       G__setgvp(G__PVOID);

       ((char_traits<char>*) (soff))->~G__Tchar_traitslEchargR();

       G__setgvp(gvp);

     }

   }

   G__setnull(result7);

   return(1 || funcname || hash || result7 || libp) ;

}

// automatic assignment operator

static int G__G__stream_11_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   char_traits<char>* dest = (char_traits<char>*) G__getstructoffset();

   const char_traits<char>& obj = *dest;

   result7->ref = (long) (&obj);

   result7->obj.i = (long) (&obj);

   return(1 || funcname || hash || result7 || libp) ;

}

/* basic_istream<char,char_traits<char> > */

static int G__G__stream_12_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

   basic_istream<char,char_traits<char> >* p = NULL;

   long gvp = G__getgvp();

   //m: 1

   if ((gvp == G__PVOID) || (gvp == 0)) {

     p = new basic_istream<char,char_traits<char> >((basic_streambuf<char,char_traits<char> >*) G__int(libp->para[0]));

   } else {

     p = new((void*) gvp) basic_istream<char,char_traits<char> >((basic_streambuf<char,char_traits<char> >*) G__int(libp->para[0]));

   }

   result7->obj.i = (long) p;

   result7->ref = (long) p;

   result7->type = 'u';

   result7->tagnum = G__get_linked_tagnum(&G__G__streamLN_basic_istreamlEcharcOchar_traitslEchargRsPgR);

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_12_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      G__letint(result7, 105, (long) ((basic_istream<char,char_traits<char> >*) G__getstructoffset())->get());

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_12_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const basic_istream<char,char_traits<char> >::__istream_type& obj = ((basic_istream<char,char_traits<char> >*) G__getstructoffset())->get((basic_istream<char,char_traits<char> >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1])

, (basic_istream<char,char_traits<char> >::char_type) G__int(libp->para[2]));

         result7->ref = (long) (&obj);

         result7->obj.i = (long) (&obj);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_12_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const basic_istream<char,char_traits<char> >::__istream_type& obj = ((basic_istream<char,char_traits<char> >*) G__getstructoffset())->get((basic_istream<char,char_traits<char> >::char_type*) G__int(libp->para[0]), (streamsize) G__Longlong(libp->para[1]));

         result7->ref = (long) (&obj);

         result7->obj.i = (long) (&obj);

      }

   return(1 || funcname || hash || result7 || libp) ;

}

static int G__G__stream_12_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{

      {

         const basic_istream<char,char_traits<char> >::__istream_type& obj = ((basic_istream<char,char_traits<char> >*) G__getstructoffset())->get(*(basic_istream<char,char_traits<char> >::char_type*) G__Charref(&libp->para[0]));

         result7->ref = (long) (&obj);

         result7->obj.i = (long) (&obj);