G__Base2.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:26:31 2011

// Do NOT change. Changes will be lost next time file is generated
//

#define R__DICTIONARY_FILENAME coredIbasedIsrcdIG__Base2
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "G__Base2.h"

#include "TCollectionProxyInfo.h"
#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
   } // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
   void TMemberInspector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMemberInspector(void *p);
   static void deleteArray_TMemberInspector(void *p);
   static void destruct_TMemberInspector(void *p);
   static void streamer_TMemberInspector(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMemberInspector*)
   {
      ::TMemberInspector *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMemberInspector >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMemberInspector", ::TMemberInspector::Class_Version(), "include/TMemberInspector.h", 31,
                  typeid(::TMemberInspector), DefineBehavior(ptr, ptr),
                  &::TMemberInspector::Dictionary, isa_proxy, 0,
                  sizeof(::TMemberInspector) );
      instance.SetDelete(&delete_TMemberInspector);
      instance.SetDeleteArray(&deleteArray_TMemberInspector);
      instance.SetDestructor(&destruct_TMemberInspector);
      instance.SetStreamerFunc(&streamer_TMemberInspector);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMemberInspector*)
   {
      return GenerateInitInstanceLocal((::TMemberInspector*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMemberInspector*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TObject(void *p = 0);
   static void *newArray_TObject(Long_t size, void *p);
   static void delete_TObject(void *p);
   static void deleteArray_TObject(void *p);
   static void destruct_TObject(void *p);
   static void streamer_TObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TObject*)
   {
      ::TObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TObject", ::TObject::Class_Version(), "include/TObject.h", 56,
                  typeid(::TObject), DefineBehavior(ptr, ptr),
                  &::TObject::Dictionary, isa_proxy, 1,
                  sizeof(::TObject) );
      instance.SetNew(&new_TObject);
      instance.SetNewArray(&newArray_TObject);
      instance.SetDelete(&delete_TObject);
      instance.SetDeleteArray(&deleteArray_TObject);
      instance.SetDestructor(&destruct_TObject);
      instance.SetStreamerFunc(&streamer_TObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TObject*)
   {
      return GenerateInitInstanceLocal((::TObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TNamed_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TNamed(void *p = 0);
   static void *newArray_TNamed(Long_t size, void *p);
   static void delete_TNamed(void *p);
   static void deleteArray_TNamed(void *p);
   static void destruct_TNamed(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNamed*)
   {
      ::TNamed *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNamed >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNamed", ::TNamed::Class_Version(), "include/TNamed.h", 33,
                  typeid(::TNamed), DefineBehavior(ptr, ptr),
                  &::TNamed::Dictionary, isa_proxy, 4,
                  sizeof(::TNamed) );
      instance.SetNew(&new_TNamed);
      instance.SetNewArray(&newArray_TNamed);
      instance.SetDelete(&delete_TNamed);
      instance.SetDeleteArray(&deleteArray_TNamed);
      instance.SetDestructor(&destruct_TNamed);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNamed*)
   {
      return GenerateInitInstanceLocal((::TNamed*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNamed*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TString_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TString(void *p = 0);
   static void *newArray_TString(Long_t size, void *p);
   static void delete_TString(void *p);
   static void deleteArray_TString(void *p);
   static void destruct_TString(void *p);
   static void streamer_TString(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TString*)
   {
      ::TString *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TString >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TString", ::TString::Class_Version(), "include/TString.h", 176,
                  typeid(::TString), DefineBehavior(ptr, ptr),
                  &::TString::Dictionary, isa_proxy, 3,
                  sizeof(::TString) );
      instance.SetNew(&new_TString);
      instance.SetNewArray(&newArray_TString);
      instance.SetDelete(&delete_TString);
      instance.SetDeleteArray(&deleteArray_TString);
      instance.SetDestructor(&destruct_TString);
      instance.SetStreamerFunc(&streamer_TString);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TString*)
   {
      return GenerateInitInstanceLocal((::TString*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TString*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void string_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void string_Dictionary();
   static void *new_string(void *p = 0);
   static void *newArray_string(Long_t size, void *p);
   static void delete_string(void *p);
   static void deleteArray_string(void *p);
   static void destruct_string(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const string*)
   {
      string *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(string),0);
      static ::ROOT::TGenericClassInfo 
         instance("string", "prec_stl/string", 39,
                  typeid(string), DefineBehavior(ptr, ptr),
                  0, &string_Dictionary, isa_proxy, 0,
                  sizeof(string) );
      instance.SetNew(&new_string);
      instance.SetNewArray(&newArray_string);
      instance.SetDelete(&delete_string);
      instance.SetDeleteArray(&deleteArray_string);
      instance.SetDestructor(&destruct_string);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const string*)
   {
      return GenerateInitInstanceLocal((string*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const string*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void string_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const string*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void stringcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void stringcLcLiterator_Dictionary();
   static void *new_stringcLcLiterator(void *p = 0);
   static void *newArray_stringcLcLiterator(Long_t size, void *p);
   static void delete_stringcLcLiterator(void *p);
   static void deleteArray_stringcLcLiterator(void *p);
   static void destruct_stringcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::string::iterator*)
   {
      ::string::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::string::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("string::iterator", "prec_stl/string", 62,
                  typeid(::string::iterator), DefineBehavior(ptr, ptr),
                  0, &stringcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::string::iterator) );
      instance.SetNew(&new_stringcLcLiterator);
      instance.SetNewArray(&newArray_stringcLcLiterator);
      instance.SetDelete(&delete_stringcLcLiterator);
      instance.SetDeleteArray(&deleteArray_stringcLcLiterator);
      instance.SetDestructor(&destruct_stringcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::string::iterator*)
   {
      return GenerateInitInstanceLocal((::string::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::string::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void stringcLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::string::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TStorage_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStorage(void *p = 0);
   static void *newArray_TStorage(Long_t size, void *p);
   static void delete_TStorage(void *p);
   static void deleteArray_TStorage(void *p);
   static void destruct_TStorage(void *p);
   static void streamer_TStorage(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStorage*)
   {
      ::TStorage *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStorage >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStorage", ::TStorage::Class_Version(), "include/TStorage.h", 34,
                  typeid(::TStorage), DefineBehavior(ptr, ptr),
                  &::TStorage::Dictionary, isa_proxy, 0,
                  sizeof(::TStorage) );
      instance.SetNew(&new_TStorage);
      instance.SetNewArray(&newArray_TStorage);
      instance.SetDelete(&delete_TStorage);
      instance.SetDeleteArray(&deleteArray_TStorage);
      instance.SetDestructor(&destruct_TStorage);
      instance.SetStreamerFunc(&streamer_TStorage);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStorage*)
   {
      return GenerateInitInstanceLocal((::TStorage*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStorage*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTimer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTimer(void *p = 0);
   static void *newArray_TTimer(Long_t size, void *p);
   static void delete_TTimer(void *p);
   static void deleteArray_TTimer(void *p);
   static void destruct_TTimer(void *p);
   static void streamer_TTimer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTimer*)
   {
      ::TTimer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTimer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTimer", ::TTimer::Class_Version(), "include/TTimer.h", 57,
                  typeid(::TTimer), DefineBehavior(ptr, ptr),
                  &::TTimer::Dictionary, isa_proxy, 0,
                  sizeof(::TTimer) );
      instance.SetNew(&new_TTimer);
      instance.SetNewArray(&newArray_TTimer);
      instance.SetDelete(&delete_TTimer);
      instance.SetDeleteArray(&deleteArray_TTimer);
      instance.SetDestructor(&destruct_TTimer);
      instance.SetStreamerFunc(&streamer_TTimer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTimer*)
   {
      return GenerateInitInstanceLocal((::TTimer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTimer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TProcessID_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProcessID(void *p = 0);
   static void *newArray_TProcessID(Long_t size, void *p);
   static void delete_TProcessID(void *p);
   static void deleteArray_TProcessID(void *p);
   static void destruct_TProcessID(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProcessID*)
   {
      ::TProcessID *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProcessID >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TProcessID", ::TProcessID::Class_Version(), "include/TProcessID.h", 34,
                  typeid(::TProcessID), DefineBehavior(ptr, ptr),
                  &::TProcessID::Dictionary, isa_proxy, 4,
                  sizeof(::TProcessID) );
      instance.SetNew(&new_TProcessID);
      instance.SetNewArray(&newArray_TProcessID);
      instance.SetDelete(&delete_TProcessID);
      instance.SetDeleteArray(&deleteArray_TProcessID);
      instance.SetDestructor(&destruct_TProcessID);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TProcessID*)
   {
      return GenerateInitInstanceLocal((::TProcessID*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProcessID*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRefCnt_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TRefCnt_Dictionary();
   static void *new_TRefCnt(void *p = 0);
   static void *newArray_TRefCnt(Long_t size, void *p);
   static void delete_TRefCnt(void *p);
   static void deleteArray_TRefCnt(void *p);
   static void destruct_TRefCnt(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRefCnt*)
   {
      ::TRefCnt *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TRefCnt),0);
      static ::ROOT::TGenericClassInfo 
         instance("TRefCnt", "include/TRefCnt.h", 29,
                  typeid(::TRefCnt), DefineBehavior(ptr, ptr),
                  0, &TRefCnt_Dictionary, isa_proxy, 0,
                  sizeof(::TRefCnt) );
      instance.SetNew(&new_TRefCnt);
      instance.SetNewArray(&newArray_TRefCnt);
      instance.SetDelete(&delete_TRefCnt);
      instance.SetDeleteArray(&deleteArray_TRefCnt);
      instance.SetDestructor(&destruct_TRefCnt);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRefCnt*)
   {
      return GenerateInitInstanceLocal((::TRefCnt*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRefCnt*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TRefCnt_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TRefCnt*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TRegexp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TRegexp(void *p);
   static void deleteArray_TRegexp(void *p);
   static void destruct_TRegexp(void *p);
   static void streamer_TRegexp(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRegexp*)
   {
      ::TRegexp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRegexp >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRegexp", ::TRegexp::Class_Version(), "include/TRegexp.h", 35,
                  typeid(::TRegexp), DefineBehavior(ptr, ptr),
                  &::TRegexp::Dictionary, isa_proxy, 0,
                  sizeof(::TRegexp) );
      instance.SetDelete(&delete_TRegexp);
      instance.SetDeleteArray(&deleteArray_TRegexp);
      instance.SetDestructor(&destruct_TRegexp);
      instance.SetStreamerFunc(&streamer_TRegexp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRegexp*)
   {
      return GenerateInitInstanceLocal((::TRegexp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRegexp*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPRegexp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPRegexp(void *p = 0);
   static void *newArray_TPRegexp(Long_t size, void *p);
   static void delete_TPRegexp(void *p);
   static void deleteArray_TPRegexp(void *p);
   static void destruct_TPRegexp(void *p);
   static void streamer_TPRegexp(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPRegexp*)
   {
      ::TPRegexp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPRegexp >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPRegexp", ::TPRegexp::Class_Version(), "include/TPRegexp.h", 42,
                  typeid(::TPRegexp), DefineBehavior(ptr, ptr),
                  &::TPRegexp::Dictionary, isa_proxy, 0,
                  sizeof(::TPRegexp) );
      instance.SetNew(&new_TPRegexp);
      instance.SetNewArray(&newArray_TPRegexp);
      instance.SetDelete(&delete_TPRegexp);
      instance.SetDeleteArray(&deleteArray_TPRegexp);
      instance.SetDestructor(&destruct_TPRegexp);
      instance.SetStreamerFunc(&streamer_TPRegexp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPRegexp*)
   {
      return GenerateInitInstanceLocal((::TPRegexp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPRegexp*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSubString_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TSubString_Dictionary();
   static void delete_TSubString(void *p);
   static void deleteArray_TSubString(void *p);
   static void destruct_TSubString(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSubString*)
   {
      ::TSubString *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TSubString),0);
      static ::ROOT::TGenericClassInfo 
         instance("TSubString", "include/TString.h", 125,
                  typeid(::TSubString), DefineBehavior(ptr, ptr),
                  0, &TSubString_Dictionary, isa_proxy, 0,
                  sizeof(::TSubString) );
      instance.SetDelete(&delete_TSubString);
      instance.SetDeleteArray(&deleteArray_TSubString);
      instance.SetDestructor(&destruct_TSubString);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSubString*)
   {
      return GenerateInitInstanceLocal((::TSubString*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSubString*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TSubString_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TSubString*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TStringRef_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TStringRef_Dictionary();
   static void *new_TStringRef(void *p = 0);
   static void *newArray_TStringRef(Long_t size, void *p);
   static void delete_TStringRef(void *p);
   static void deleteArray_TStringRef(void *p);
   static void destruct_TStringRef(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStringRef*)
   {
      ::TStringRef *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TStringRef),0);
      static ::ROOT::TGenericClassInfo 
         instance("TStringRef", "include/TString.h", 88,
                  typeid(::TStringRef), DefineBehavior(ptr, ptr),
                  0, &TStringRef_Dictionary, isa_proxy, 3,
                  sizeof(::TStringRef) );
      instance.SetNew(&new_TStringRef);
      instance.SetNewArray(&newArray_TStringRef);
      instance.SetDelete(&delete_TStringRef);
      instance.SetDeleteArray(&deleteArray_TStringRef);
      instance.SetDestructor(&destruct_TStringRef);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStringRef*)
   {
      return GenerateInitInstanceLocal((::TStringRef*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStringRef*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TStringRef_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TStringRef*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TStringLong_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStringLong(void *p = 0);
   static void *newArray_TStringLong(Long_t size, void *p);
   static void delete_TStringLong(void *p);
   static void deleteArray_TStringLong(void *p);
   static void destruct_TStringLong(void *p);
   static void streamer_TStringLong(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStringLong*)
   {
      ::TStringLong *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStringLong >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStringLong", ::TStringLong::Class_Version(), "include/TStringLong.h", 33,
                  typeid(::TStringLong), DefineBehavior(ptr, ptr),
                  &::TStringLong::Dictionary, isa_proxy, 1,
                  sizeof(::TStringLong) );
      instance.SetNew(&new_TStringLong);
      instance.SetNewArray(&newArray_TStringLong);
      instance.SetDelete(&delete_TStringLong);
      instance.SetDeleteArray(&deleteArray_TStringLong);
      instance.SetDestructor(&destruct_TStringLong);
      instance.SetStreamerFunc(&streamer_TStringLong);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStringLong*)
   {
      return GenerateInitInstanceLocal((::TStringLong*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStringLong*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQConnection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TQConnection(void *p = 0);
   static void *newArray_TQConnection(Long_t size, void *p);
   static void delete_TQConnection(void *p);
   static void deleteArray_TQConnection(void *p);
   static void destruct_TQConnection(void *p);
   static void streamer_TQConnection(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQConnection*)
   {
      ::TQConnection *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQConnection >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQConnection", ::TQConnection::Class_Version(), "include/TQConnection.h", 43,
                  typeid(::TQConnection), DefineBehavior(ptr, ptr),
                  &::TQConnection::Dictionary, isa_proxy, 0,
                  sizeof(::TQConnection) );
      instance.SetNew(&new_TQConnection);
      instance.SetNewArray(&newArray_TQConnection);
      instance.SetDelete(&delete_TQConnection);
      instance.SetDeleteArray(&deleteArray_TQConnection);
      instance.SetDestructor(&destruct_TQConnection);
      instance.SetStreamerFunc(&streamer_TQConnection);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQConnection*)
   {
      return GenerateInitInstanceLocal((::TQConnection*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQConnection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TQObject(void *p = 0);
   static void *newArray_TQObject(Long_t size, void *p);
   static void delete_TQObject(void *p);
   static void deleteArray_TQObject(void *p);
   static void destruct_TQObject(void *p);
   static void streamer_TQObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQObject*)
   {
      ::TQObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQObject", ::TQObject::Class_Version(), "include/TQObject.h", 49,
                  typeid(::TQObject), DefineBehavior(ptr, ptr),
                  &::TQObject::Dictionary, isa_proxy, 1,
                  sizeof(::TQObject) );
      instance.SetNew(&new_TQObject);
      instance.SetNewArray(&newArray_TQObject);
      instance.SetDelete(&delete_TQObject);
      instance.SetDeleteArray(&deleteArray_TQObject);
      instance.SetDestructor(&destruct_TQObject);
      instance.SetStreamerFunc(&streamer_TQObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQObject*)
   {
      return GenerateInitInstanceLocal((::TQObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQObjSender_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TQObjSender(void *p = 0);
   static void *newArray_TQObjSender(Long_t size, void *p);
   static void delete_TQObjSender(void *p);
   static void deleteArray_TQObjSender(void *p);
   static void destruct_TQObjSender(void *p);
   static void streamer_TQObjSender(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQObjSender*)
   {
      ::TQObjSender *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQObjSender >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQObjSender", ::TQObjSender::Class_Version(), "include/TQObject.h", 187,
                  typeid(::TQObjSender), DefineBehavior(ptr, ptr),
                  &::TQObjSender::Dictionary, isa_proxy, 0,
                  sizeof(::TQObjSender) );
      instance.SetNew(&new_TQObjSender);
      instance.SetNewArray(&newArray_TQObjSender);
      instance.SetDelete(&delete_TQObjSender);
      instance.SetDeleteArray(&deleteArray_TQObjSender);
      instance.SetDestructor(&destruct_TQObjSender);
      instance.SetStreamerFunc(&streamer_TQObjSender);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQObjSender*)
   {
      return GenerateInitInstanceLocal((::TQObjSender*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQObjSender*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSignalHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSignalHandler(void *p);
   static void deleteArray_TSignalHandler(void *p);
   static void destruct_TSignalHandler(void *p);
   static void streamer_TSignalHandler(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSignalHandler*)
   {
      ::TSignalHandler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSignalHandler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSignalHandler", ::TSignalHandler::Class_Version(), "include/TSysEvtHandler.h", 130,
                  typeid(::TSignalHandler), DefineBehavior(ptr, ptr),
                  &::TSignalHandler::Dictionary, isa_proxy, 0,
                  sizeof(::TSignalHandler) );
      instance.SetDelete(&delete_TSignalHandler);
      instance.SetDeleteArray(&deleteArray_TSignalHandler);
      instance.SetDestructor(&destruct_TSignalHandler);
      instance.SetStreamerFunc(&streamer_TSignalHandler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSignalHandler*)
   {
      return GenerateInitInstanceLocal((::TSignalHandler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSignalHandler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStopwatch_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TStopwatch(void *p = 0);
   static void *newArray_TStopwatch(Long_t size, void *p);
   static void delete_TStopwatch(void *p);
   static void deleteArray_TStopwatch(void *p);
   static void destruct_TStopwatch(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStopwatch*)
   {
      ::TStopwatch *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStopwatch >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStopwatch", ::TStopwatch::Class_Version(), "include/TStopwatch.h", 30,
                  typeid(::TStopwatch), DefineBehavior(ptr, ptr),
                  &::TStopwatch::Dictionary, isa_proxy, 4,
                  sizeof(::TStopwatch) );
      instance.SetNew(&new_TStopwatch);
      instance.SetNewArray(&newArray_TStopwatch);
      instance.SetDelete(&delete_TStopwatch);
      instance.SetDeleteArray(&deleteArray_TStopwatch);
      instance.SetDestructor(&destruct_TStopwatch);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStopwatch*)
   {
      return GenerateInitInstanceLocal((::TStopwatch*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStopwatch*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TUUID_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TUUID(void *p = 0);
   static void *newArray_TUUID(Long_t size, void *p);
   static void delete_TUUID(void *p);
   static void deleteArray_TUUID(void *p);
   static void destruct_TUUID(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TUUID*)
   {
      ::TUUID *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TUUID >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TUUID", ::TUUID::Class_Version(), "include/TUUID.h", 44,
                  typeid(::TUUID), DefineBehavior(ptr, ptr),
                  &::TUUID::Dictionary, isa_proxy, 4,
                  sizeof(::TUUID) );
      instance.SetNew(&new_TUUID);
      instance.SetNewArray(&newArray_TUUID);
      instance.SetDelete(&delete_TUUID);
      instance.SetDeleteArray(&deleteArray_TUUID);
      instance.SetDestructor(&destruct_TUUID);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TUUID*)
   {
      return GenerateInitInstanceLocal((::TUUID*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TUUID*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TExec_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TExec(void *p = 0);
   static void *newArray_TExec(Long_t size, void *p);
   static void delete_TExec(void *p);
   static void deleteArray_TExec(void *p);
   static void destruct_TExec(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TExec*)
   {
      ::TExec *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExec >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TExec", ::TExec::Class_Version(), "include/TExec.h", 30,
                  typeid(::TExec), DefineBehavior(ptr, ptr),
                  &::TExec::Dictionary, isa_proxy, 4,
                  sizeof(::TExec) );
      instance.SetNew(&new_TExec);
      instance.SetNewArray(&newArray_TExec);
      instance.SetDelete(&delete_TExec);
      instance.SetDeleteArray(&deleteArray_TExec);
      instance.SetDestructor(&destruct_TExec);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TExec*)
   {
      return GenerateInitInstanceLocal((::TExec*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TExec*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFolder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFolder(void *p = 0);
   static void *newArray_TFolder(Long_t size, void *p);
   static void delete_TFolder(void *p);
   static void deleteArray_TFolder(void *p);
   static void destruct_TFolder(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFolder*)
   {
      ::TFolder *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFolder >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFolder", ::TFolder::Class_Version(), "include/TFolder.h", 32,
                  typeid(::TFolder), DefineBehavior(ptr, ptr),
                  &::TFolder::Dictionary, isa_proxy, 4,
                  sizeof(::TFolder) );
      instance.SetNew(&new_TFolder);
      instance.SetNewArray(&newArray_TFolder);
      instance.SetDelete(&delete_TFolder);
      instance.SetDeleteArray(&deleteArray_TFolder);
      instance.SetDestructor(&destruct_TFolder);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFolder*)
   {
      return GenerateInitInstanceLocal((::TFolder*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFolder*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TObjString_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TObjString(void *p = 0);
   static void *newArray_TObjString(Long_t size, void *p);
   static void delete_TObjString(void *p);
   static void deleteArray_TObjString(void *p);
   static void destruct_TObjString(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TObjString*)
   {
      ::TObjString *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TObjString >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TObjString", ::TObjString::Class_Version(), "include/TObjString.h", 32,
                  typeid(::TObjString), DefineBehavior(ptr, ptr),
                  &::TObjString::Dictionary, isa_proxy, 4,
                  sizeof(::TObjString) );
      instance.SetNew(&new_TObjString);
      instance.SetNewArray(&newArray_TObjString);
      instance.SetDelete(&delete_TObjString);
      instance.SetDeleteArray(&deleteArray_TObjString);
      instance.SetDestructor(&destruct_TObjString);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TObjString*)
   {
      return GenerateInitInstanceLocal((::TObjString*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TObjString*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMD5_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMD5(void *p = 0);
   static void *newArray_TMD5(Long_t size, void *p);
   static void delete_TMD5(void *p);
   static void deleteArray_TMD5(void *p);
   static void destruct_TMD5(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMD5*)
   {
      ::TMD5 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMD5 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMD5", ::TMD5::Class_Version(), "include/TMD5.h", 46,
                  typeid(::TMD5), DefineBehavior(ptr, ptr),
                  &::TMD5::Dictionary, isa_proxy, 4,
                  sizeof(::TMD5) );
      instance.SetNew(&new_TMD5);
      instance.SetNewArray(&newArray_TMD5);
      instance.SetDelete(&delete_TMD5);
      instance.SetDeleteArray(&deleteArray_TMD5);
      instance.SetDestructor(&destruct_TMD5);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMD5*)
   {
      return GenerateInitInstanceLocal((::TMD5*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMD5*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMacro_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMacro(void *p = 0);
   static void *newArray_TMacro(Long_t size, void *p);
   static void delete_TMacro(void *p);
   static void deleteArray_TMacro(void *p);
   static void destruct_TMacro(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMacro*)
   {
      ::TMacro *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMacro >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMacro", ::TMacro::Class_Version(), "include/TMacro.h", 33,
                  typeid(::TMacro), DefineBehavior(ptr, ptr),
                  &::TMacro::Dictionary, isa_proxy, 4,
                  sizeof(::TMacro) );
      instance.SetNew(&new_TMacro);
      instance.SetNewArray(&newArray_TMacro);
      instance.SetDelete(&delete_TMacro);
      instance.SetDeleteArray(&deleteArray_TMacro);
      instance.SetDestructor(&destruct_TMacro);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMacro*)
   {
      return GenerateInitInstanceLocal((::TMacro*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMacro*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMessageHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMessageHandler(void *p);
   static void deleteArray_TMessageHandler(void *p);
   static void destruct_TMessageHandler(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMessageHandler*)
   {
      ::TMessageHandler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMessageHandler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMessageHandler", ::TMessageHandler::Class_Version(), "include/TMessageHandler.h", 38,
                  typeid(::TMessageHandler), DefineBehavior(ptr, ptr),
                  &::TMessageHandler::Dictionary, isa_proxy, 4,
                  sizeof(::TMessageHandler) );
      instance.SetDelete(&delete_TMessageHandler);
      instance.SetDeleteArray(&deleteArray_TMessageHandler);
      instance.SetDestructor(&destruct_TMessageHandler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMessageHandler*)
   {
      return GenerateInitInstanceLocal((::TMessageHandler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMessageHandler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPluginManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPluginManager(void *p = 0);
   static void *newArray_TPluginManager(Long_t size, void *p);
   static void delete_TPluginManager(void *p);
   static void deleteArray_TPluginManager(void *p);
   static void destruct_TPluginManager(void *p);
   static void streamer_TPluginManager(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPluginManager*)
   {
      ::TPluginManager *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPluginManager >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPluginManager", ::TPluginManager::Class_Version(), "include/TPluginManager.h", 152,
                  typeid(::TPluginManager), DefineBehavior(ptr, ptr),
                  &::TPluginManager::Dictionary, isa_proxy, 0,
                  sizeof(::TPluginManager) );
      instance.SetNew(&new_TPluginManager);
      instance.SetNewArray(&newArray_TPluginManager);
      instance.SetDelete(&delete_TPluginManager);
      instance.SetDeleteArray(&deleteArray_TPluginManager);
      instance.SetDestructor(&destruct_TPluginManager);
      instance.SetStreamerFunc(&streamer_TPluginManager);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPluginManager*)
   {
      return GenerateInitInstanceLocal((::TPluginManager*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPluginManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPluginHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void streamer_TPluginHandler(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPluginHandler*)
   {
      ::TPluginHandler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPluginHandler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPluginHandler", ::TPluginHandler::Class_Version(), "include/TPluginManager.h", 103,
                  typeid(::TPluginHandler), DefineBehavior(ptr, ptr),
                  &::TPluginHandler::Dictionary, isa_proxy, 0,
                  sizeof(::TPluginHandler) );
      instance.SetStreamerFunc(&streamer_TPluginHandler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPluginHandler*)
   {
      return GenerateInitInstanceLocal((::TPluginHandler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPluginHandler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPoint_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TPoint_Dictionary();
   static void *new_TPoint(void *p = 0);
   static void *newArray_TPoint(Long_t size, void *p);
   static void delete_TPoint(void *p);
   static void deleteArray_TPoint(void *p);
   static void destruct_TPoint(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPoint*)
   {
      ::TPoint *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TPoint),0);
      static ::ROOT::TGenericClassInfo 
         instance("TPoint", "include/TPoint.h", 33,
                  typeid(::TPoint), DefineBehavior(ptr, ptr),
                  0, &TPoint_Dictionary, isa_proxy, 0,
                  sizeof(::TPoint) );
      instance.SetNew(&new_TPoint);
      instance.SetNewArray(&newArray_TPoint);
      instance.SetDelete(&delete_TPoint);
      instance.SetDeleteArray(&deleteArray_TPoint);
      instance.SetDestructor(&destruct_TPoint);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPoint*)
   {
      return GenerateInitInstanceLocal((::TPoint*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPoint*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TPoint_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TPoint*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TPMERegexp_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPMERegexp(void *p = 0);
   static void *newArray_TPMERegexp(Long_t size, void *p);
   static void delete_TPMERegexp(void *p);
   static void deleteArray_TPMERegexp(void *p);
   static void destruct_TPMERegexp(void *p);
   static void streamer_TPMERegexp(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPMERegexp*)
   {
      ::TPMERegexp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPMERegexp >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPMERegexp", ::TPMERegexp::Class_Version(), "include/TPRegexp.h", 96,
                  typeid(::TPMERegexp), DefineBehavior(ptr, ptr),
                  &::TPMERegexp::Dictionary, isa_proxy, 0,
                  sizeof(::TPMERegexp) );
      instance.SetNew(&new_TPMERegexp);
      instance.SetNewArray(&newArray_TPMERegexp);
      instance.SetDelete(&delete_TPMERegexp);
      instance.SetDeleteArray(&deleteArray_TPMERegexp);
      instance.SetDestructor(&destruct_TPMERegexp);
      instance.SetStreamerFunc(&streamer_TPMERegexp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPMERegexp*)
   {
      return GenerateInitInstanceLocal((::TPMERegexp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPMERegexp*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStringToken_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStringToken(void *p);
   static void deleteArray_TStringToken(void *p);
   static void destruct_TStringToken(void *p);
   static void streamer_TStringToken(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStringToken*)
   {
      ::TStringToken *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStringToken >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStringToken", ::TStringToken::Class_Version(), "include/TPRegexp.h", 142,
                  typeid(::TStringToken), DefineBehavior(ptr, ptr),
                  &::TStringToken::Dictionary, isa_proxy, 0,
                  sizeof(::TStringToken) );
      instance.SetDelete(&delete_TStringToken);
      instance.SetDeleteArray(&deleteArray_TStringToken);
      instance.SetDestructor(&destruct_TStringToken);
      instance.SetStreamerFunc(&streamer_TStringToken);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStringToken*)
   {
      return GenerateInitInstanceLocal((::TStringToken*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStringToken*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TProcessUUID_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProcessUUID(void *p = 0);
   static void *newArray_TProcessUUID(Long_t size, void *p);
   static void delete_TProcessUUID(void *p);
   static void deleteArray_TProcessUUID(void *p);
   static void destruct_TProcessUUID(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProcessUUID*)
   {
      ::TProcessUUID *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProcessUUID >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TProcessUUID", ::TProcessUUID::Class_Version(), "include/TProcessUUID.h", 34,
                  typeid(::TProcessUUID), DefineBehavior(ptr, ptr),
                  &::TProcessUUID::Dictionary, isa_proxy, 4,
                  sizeof(::TProcessUUID) );
      instance.SetNew(&new_TProcessUUID);
      instance.SetNewArray(&newArray_TProcessUUID);
      instance.SetDelete(&delete_TProcessUUID);
      instance.SetDeleteArray(&deleteArray_TProcessUUID);
      instance.SetDestructor(&destruct_TProcessUUID);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TProcessUUID*)
   {
      return GenerateInitInstanceLocal((::TProcessUUID*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProcessUUID*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQClass_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TQClass(void *p);
   static void deleteArray_TQClass(void *p);
   static void destruct_TQClass(void *p);
   static void streamer_TQClass(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQClass*)
   {
      ::TQClass *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQClass >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQClass", ::TQClass::Class_Version(), "include/TQClass.h", 37,
                  typeid(::TQClass), DefineBehavior(ptr, ptr),
                  &::TQClass::Dictionary, isa_proxy, 0,
                  sizeof(::TQClass) );
      instance.SetDelete(&delete_TQClass);
      instance.SetDeleteArray(&deleteArray_TQClass);
      instance.SetDestructor(&destruct_TQClass);
      instance.SetStreamerFunc(&streamer_TQClass);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQClass*)
   {
      return GenerateInitInstanceLocal((::TQClass*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQClass*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQCommand_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TQCommand(void *p = 0);
   static void *newArray_TQCommand(Long_t size, void *p);
   static void delete_TQCommand(void *p);
   static void deleteArray_TQCommand(void *p);
   static void destruct_TQCommand(void *p);
   static void streamer_TQCommand(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQCommand*)
   {
      ::TQCommand *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQCommand >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQCommand", ::TQCommand::Class_Version(), "include/TQCommand.h", 29,
                  typeid(::TQCommand), DefineBehavior(ptr, ptr),
                  &::TQCommand::Dictionary, isa_proxy, 0,
                  sizeof(::TQCommand) );
      instance.SetNew(&new_TQCommand);
      instance.SetNewArray(&newArray_TQCommand);
      instance.SetDelete(&delete_TQCommand);
      instance.SetDeleteArray(&deleteArray_TQCommand);
      instance.SetDestructor(&destruct_TQCommand);
      instance.SetStreamerFunc(&streamer_TQCommand);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQCommand*)
   {
      return GenerateInitInstanceLocal((::TQCommand*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQCommand*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQUndoManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TQUndoManager(void *p = 0);
   static void *newArray_TQUndoManager(Long_t size, void *p);
   static void delete_TQUndoManager(void *p);
   static void deleteArray_TQUndoManager(void *p);
   static void destruct_TQUndoManager(void *p);
   static void streamer_TQUndoManager(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQUndoManager*)
   {
      ::TQUndoManager *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQUndoManager >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQUndoManager", ::TQUndoManager::Class_Version(), "include/TQCommand.h", 101,
                  typeid(::TQUndoManager), DefineBehavior(ptr, ptr),
                  &::TQUndoManager::Dictionary, isa_proxy, 0,
                  sizeof(::TQUndoManager) );
      instance.SetNew(&new_TQUndoManager);
      instance.SetNewArray(&newArray_TQUndoManager);
      instance.SetDelete(&delete_TQUndoManager);
      instance.SetDeleteArray(&deleteArray_TQUndoManager);
      instance.SetDestructor(&destruct_TQUndoManager);
      instance.SetStreamerFunc(&streamer_TQUndoManager);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQUndoManager*)
   {
      return GenerateInitInstanceLocal((::TQUndoManager*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQUndoManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRef_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRef(void *p = 0);
   static void *newArray_TRef(Long_t size, void *p);
   static void delete_TRef(void *p);
   static void deleteArray_TRef(void *p);
   static void destruct_TRef(void *p);
   static void streamer_TRef(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRef*)
   {
      ::TRef *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRef >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRef", ::TRef::Class_Version(), "include/TRef.h", 34,
                  typeid(::TRef), DefineBehavior(ptr, ptr),
                  &::TRef::Dictionary, isa_proxy, 1,
                  sizeof(::TRef) );
      instance.SetNew(&new_TRef);
      instance.SetNewArray(&newArray_TRef);
      instance.SetDelete(&delete_TRef);
      instance.SetDeleteArray(&deleteArray_TRef);
      instance.SetDestructor(&destruct_TRef);
      instance.SetStreamerFunc(&streamer_TRef);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRef*)
   {
      return GenerateInitInstanceLocal((::TRef*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRef*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSystemFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSystemFile(void *p = 0);
   static void *newArray_TSystemFile(Long_t size, void *p);
   static void delete_TSystemFile(void *p);
   static void deleteArray_TSystemFile(void *p);
   static void destruct_TSystemFile(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSystemFile*)
   {
      ::TSystemFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSystemFile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSystemFile", ::TSystemFile::Class_Version(), "include/TSystemFile.h", 31,
                  typeid(::TSystemFile), DefineBehavior(ptr, ptr),
                  &::TSystemFile::Dictionary, isa_proxy, 4,
                  sizeof(::TSystemFile) );
      instance.SetNew(&new_TSystemFile);
      instance.SetNewArray(&newArray_TSystemFile);
      instance.SetDelete(&delete_TSystemFile);
      instance.SetDeleteArray(&deleteArray_TSystemFile);
      instance.SetDestructor(&destruct_TSystemFile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSystemFile*)
   {
      return GenerateInitInstanceLocal((::TSystemFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSystemFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSystemDirectory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSystemDirectory(void *p = 0);
   static void *newArray_TSystemDirectory(Long_t size, void *p);
   static void delete_TSystemDirectory(void *p);
   static void deleteArray_TSystemDirectory(void *p);
   static void destruct_TSystemDirectory(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSystemDirectory*)
   {
      ::TSystemDirectory *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSystemDirectory >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSystemDirectory", ::TSystemDirectory::Class_Version(), "include/TSystemDirectory.h", 34,
                  typeid(::TSystemDirectory), DefineBehavior(ptr, ptr),
                  &::TSystemDirectory::Dictionary, isa_proxy, 4,
                  sizeof(::TSystemDirectory) );
      instance.SetNew(&new_TSystemDirectory);
      instance.SetNewArray(&newArray_TSystemDirectory);
      instance.SetDelete(&delete_TSystemDirectory);
      instance.SetDeleteArray(&deleteArray_TSystemDirectory);
      instance.SetDestructor(&destruct_TSystemDirectory);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSystemDirectory*)
   {
      return GenerateInitInstanceLocal((::TSystemDirectory*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSystemDirectory*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSystem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSystem(void *p = 0);
   static void *newArray_TSystem(Long_t size, void *p);
   static void delete_TSystem(void *p);
   static void deleteArray_TSystem(void *p);
   static void destruct_TSystem(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSystem*)
   {
      ::TSystem *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSystem >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSystem", ::TSystem::Class_Version(), "include/TSystem.h", 262,
                  typeid(::TSystem), DefineBehavior(ptr, ptr),
                  &::TSystem::Dictionary, isa_proxy, 4,
                  sizeof(::TSystem) );
      instance.SetNew(&new_TSystem);
      instance.SetNewArray(&newArray_TSystem);
      instance.SetDelete(&delete_TSystem);
      instance.SetDeleteArray(&deleteArray_TSystem);
      instance.SetDestructor(&destruct_TSystem);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSystem*)
   {
      return GenerateInitInstanceLocal((::TSystem*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSystem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator_Dictionary();
   static void *new_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p = 0);
   static void *newArray_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(Long_t size, void *p);
   static void delete_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p);
   static void deleteArray_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p);
   static void destruct_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::vector<TString,allocator<TString> >::iterator*)
   {
      ::vector<TString,allocator<TString> >::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::vector<TString,allocator<TString> >::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TString,allocator<TString> >::iterator", "prec_stl/vector", 218,
                  typeid(::vector<TString,allocator<TString> >::iterator), DefineBehavior(ptr, ptr),
                  0, &vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::vector<TString,allocator<TString> >::iterator) );
      instance.SetNew(&new_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator);
      instance.SetNewArray(&newArray_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator);
      instance.SetDelete(&delete_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator);
      instance.SetDeleteArray(&deleteArray_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator);
      instance.SetDestructor(&destruct_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::vector<TString,allocator<TString> >::iterator*)
   {
      return GenerateInitInstanceLocal((::vector<TString,allocator<TString> >::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::vector<TString,allocator<TString> >::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::vector<TString,allocator<TString> >::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR_Dictionary();
   static void *new_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p = 0);
   static void *newArray_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(Long_t size, void *p);
   static void delete_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p);
   static void deleteArray_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p);
   static void destruct_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)
   {
      ::reverse_iterator<vector<TString,allocator<TString> >::iterator> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::reverse_iterator<vector<TString,allocator<TString> >::iterator>),0);
      static ::ROOT::TGenericClassInfo 
         instance("reverse_iterator<vector<TString,allocator<TString> >::iterator>", "prec_stl/iterator", 166,
                  typeid(::reverse_iterator<vector<TString,allocator<TString> >::iterator>), DefineBehavior(ptr, ptr),
                  0, &reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR_Dictionary, isa_proxy, 0,
                  sizeof(::reverse_iterator<vector<TString,allocator<TString> >::iterator>) );
      instance.SetNew(&new_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
      instance.SetNewArray(&newArray_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
      instance.SetDelete(&delete_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
      instance.SetDeleteArray(&deleteArray_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
      instance.SetDestructor(&destruct_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)
   {
      return GenerateInitInstanceLocal((::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TSysEvtHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSysEvtHandler(void *p);
   static void deleteArray_TSysEvtHandler(void *p);
   static void destruct_TSysEvtHandler(void *p);
   static void streamer_TSysEvtHandler(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSysEvtHandler*)
   {
      ::TSysEvtHandler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSysEvtHandler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSysEvtHandler", ::TSysEvtHandler::Class_Version(), "include/TSysEvtHandler.h", 32,
                  typeid(::TSysEvtHandler), DefineBehavior(ptr, ptr),
                  &::TSysEvtHandler::Dictionary, isa_proxy, 0,
                  sizeof(::TSysEvtHandler) );
      instance.SetDelete(&delete_TSysEvtHandler);
      instance.SetDeleteArray(&deleteArray_TSysEvtHandler);
      instance.SetDestructor(&destruct_TSysEvtHandler);
      instance.SetStreamerFunc(&streamer_TSysEvtHandler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSysEvtHandler*)
   {
      return GenerateInitInstanceLocal((::TSysEvtHandler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSysEvtHandler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TStdExceptionHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TStdExceptionHandler(void *p);
   static void deleteArray_TStdExceptionHandler(void *p);
   static void destruct_TStdExceptionHandler(void *p);
   static void streamer_TStdExceptionHandler(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStdExceptionHandler*)
   {
      ::TStdExceptionHandler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStdExceptionHandler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TStdExceptionHandler", ::TStdExceptionHandler::Class_Version(), "include/TSysEvtHandler.h", 175,
                  typeid(::TStdExceptionHandler), DefineBehavior(ptr, ptr),
                  &::TStdExceptionHandler::Dictionary, isa_proxy, 0,
                  sizeof(::TStdExceptionHandler) );
      instance.SetDelete(&delete_TStdExceptionHandler);
      instance.SetDeleteArray(&deleteArray_TStdExceptionHandler);
      instance.SetDestructor(&destruct_TStdExceptionHandler);
      instance.SetStreamerFunc(&streamer_TStdExceptionHandler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TStdExceptionHandler*)
   {
      return GenerateInitInstanceLocal((::TStdExceptionHandler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStdExceptionHandler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTime_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTime(void *p = 0);
   static void *newArray_TTime(Long_t size, void *p);
   static void delete_TTime(void *p);
   static void deleteArray_TTime(void *p);
   static void destruct_TTime(void *p);
   static void streamer_TTime(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTime*)
   {
      ::TTime *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTime >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTime", ::TTime::Class_Version(), "include/TTime.h", 29,
                  typeid(::TTime), DefineBehavior(ptr, ptr),
                  &::TTime::Dictionary, isa_proxy, 0,
                  sizeof(::TTime) );
      instance.SetNew(&new_TTime);
      instance.SetNewArray(&newArray_TTime);
      instance.SetDelete(&delete_TTime);
      instance.SetDeleteArray(&deleteArray_TTime);
      instance.SetDestructor(&destruct_TTime);
      instance.SetStreamerFunc(&streamer_TTime);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTime*)
   {
      return GenerateInitInstanceLocal((::TTime*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTime*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void FileStat_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void FileStat_t_Dictionary();
   static void *new_FileStat_t(void *p = 0);
   static void *newArray_FileStat_t(Long_t size, void *p);
   static void delete_FileStat_t(void *p);
   static void deleteArray_FileStat_t(void *p);
   static void destruct_FileStat_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::FileStat_t*)
   {
      ::FileStat_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::FileStat_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("FileStat_t", "include/TSystem.h", 139,
                  typeid(::FileStat_t), DefineBehavior(ptr, ptr),
                  0, &FileStat_t_Dictionary, isa_proxy, 0,
                  sizeof(::FileStat_t) );
      instance.SetNew(&new_FileStat_t);
      instance.SetNewArray(&newArray_FileStat_t);
      instance.SetDelete(&delete_FileStat_t);
      instance.SetDeleteArray(&deleteArray_FileStat_t);
      instance.SetDestructor(&destruct_FileStat_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::FileStat_t*)
   {
      return GenerateInitInstanceLocal((::FileStat_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::FileStat_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void FileStat_t_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::FileStat_t*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void UserGroup_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void UserGroup_t_Dictionary();
   static void *new_UserGroup_t(void *p = 0);
   static void *newArray_UserGroup_t(Long_t size, void *p);
   static void delete_UserGroup_t(void *p);
   static void deleteArray_UserGroup_t(void *p);
   static void destruct_UserGroup_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::UserGroup_t*)
   {
      ::UserGroup_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::UserGroup_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("UserGroup_t", "include/TSystem.h", 153,
                  typeid(::UserGroup_t), DefineBehavior(ptr, ptr),
                  0, &UserGroup_t_Dictionary, isa_proxy, 0,
                  sizeof(::UserGroup_t) );
      instance.SetNew(&new_UserGroup_t);
      instance.SetNewArray(&newArray_UserGroup_t);
      instance.SetDelete(&delete_UserGroup_t);
      instance.SetDeleteArray(&deleteArray_UserGroup_t);
      instance.SetDestructor(&destruct_UserGroup_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::UserGroup_t*)
   {
      return GenerateInitInstanceLocal((::UserGroup_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::UserGroup_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void UserGroup_t_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::UserGroup_t*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void SysInfo_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_SysInfo_t(void *p = 0);
   static void *newArray_SysInfo_t(Long_t size, void *p);
   static void delete_SysInfo_t(void *p);
   static void deleteArray_SysInfo_t(void *p);
   static void destruct_SysInfo_t(void *p);
   static void streamer_SysInfo_t(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SysInfo_t*)
   {
      ::SysInfo_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SysInfo_t >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SysInfo_t", ::SysInfo_t::Class_Version(), "include/TSystem.h", 165,
                  typeid(::SysInfo_t), DefineBehavior(ptr, ptr),
                  &::SysInfo_t::Dictionary, isa_proxy, 0,
                  sizeof(::SysInfo_t) );
      instance.SetNew(&new_SysInfo_t);
      instance.SetNewArray(&newArray_SysInfo_t);
      instance.SetDelete(&delete_SysInfo_t);
      instance.SetDeleteArray(&deleteArray_SysInfo_t);
      instance.SetDestructor(&destruct_SysInfo_t);
      instance.SetStreamerFunc(&streamer_SysInfo_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SysInfo_t*)
   {
      return GenerateInitInstanceLocal((::SysInfo_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::SysInfo_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void CpuInfo_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_CpuInfo_t(void *p = 0);
   static void *newArray_CpuInfo_t(Long_t size, void *p);
   static void delete_CpuInfo_t(void *p);
   static void deleteArray_CpuInfo_t(void *p);
   static void destruct_CpuInfo_t(void *p);
   static void streamer_CpuInfo_t(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::CpuInfo_t*)
   {
      ::CpuInfo_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::CpuInfo_t >(0);
      static ::ROOT::TGenericClassInfo 
         instance("CpuInfo_t", ::CpuInfo_t::Class_Version(), "include/TSystem.h", 180,
                  typeid(::CpuInfo_t), DefineBehavior(ptr, ptr),
                  &::CpuInfo_t::Dictionary, isa_proxy, 0,
                  sizeof(::CpuInfo_t) );
      instance.SetNew(&new_CpuInfo_t);
      instance.SetNewArray(&newArray_CpuInfo_t);
      instance.SetDelete(&delete_CpuInfo_t);
      instance.SetDeleteArray(&deleteArray_CpuInfo_t);
      instance.SetDestructor(&destruct_CpuInfo_t);
      instance.SetStreamerFunc(&streamer_CpuInfo_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::CpuInfo_t*)
   {
      return GenerateInitInstanceLocal((::CpuInfo_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::CpuInfo_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void MemInfo_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_MemInfo_t(void *p = 0);
   static void *newArray_MemInfo_t(Long_t size, void *p);
   static void delete_MemInfo_t(void *p);
   static void deleteArray_MemInfo_t(void *p);
   static void destruct_MemInfo_t(void *p);
   static void streamer_MemInfo_t(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::MemInfo_t*)
   {
      ::MemInfo_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MemInfo_t >(0);
      static ::ROOT::TGenericClassInfo 
         instance("MemInfo_t", ::MemInfo_t::Class_Version(), "include/TSystem.h", 194,
                  typeid(::MemInfo_t), DefineBehavior(ptr, ptr),
                  &::MemInfo_t::Dictionary, isa_proxy, 0,
                  sizeof(::MemInfo_t) );
      instance.SetNew(&new_MemInfo_t);
      instance.SetNewArray(&newArray_MemInfo_t);
      instance.SetDelete(&delete_MemInfo_t);
      instance.SetDeleteArray(&deleteArray_MemInfo_t);
      instance.SetDestructor(&destruct_MemInfo_t);
      instance.SetStreamerFunc(&streamer_MemInfo_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::MemInfo_t*)
   {
      return GenerateInitInstanceLocal((::MemInfo_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MemInfo_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void ProcInfo_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_ProcInfo_t(void *p = 0);
   static void *newArray_ProcInfo_t(Long_t size, void *p);
   static void delete_ProcInfo_t(void *p);
   static void deleteArray_ProcInfo_t(void *p);
   static void destruct_ProcInfo_t(void *p);
   static void streamer_ProcInfo_t(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ProcInfo_t*)
   {
      ::ProcInfo_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ProcInfo_t >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ProcInfo_t", ::ProcInfo_t::Class_Version(), "include/TSystem.h", 207,
                  typeid(::ProcInfo_t), DefineBehavior(ptr, ptr),
                  &::ProcInfo_t::Dictionary, isa_proxy, 0,
                  sizeof(::ProcInfo_t) );
      instance.SetNew(&new_ProcInfo_t);
      instance.SetNewArray(&newArray_ProcInfo_t);
      instance.SetDelete(&delete_ProcInfo_t);
      instance.SetDeleteArray(&deleteArray_ProcInfo_t);
      instance.SetDestructor(&destruct_ProcInfo_t);
      instance.SetStreamerFunc(&streamer_ProcInfo_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ProcInfo_t*)
   {
      return GenerateInitInstanceLocal((::ProcInfo_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ProcInfo_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RedirectHandle_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RedirectHandle_t_Dictionary();
   static void *new_RedirectHandle_t(void *p = 0);
   static void *newArray_RedirectHandle_t(Long_t size, void *p);
   static void delete_RedirectHandle_t(void *p);
   static void deleteArray_RedirectHandle_t(void *p);
   static void destruct_RedirectHandle_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RedirectHandle_t*)
   {
      ::RedirectHandle_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RedirectHandle_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("RedirectHandle_t", "include/TSystem.h", 218,
                  typeid(::RedirectHandle_t), DefineBehavior(ptr, ptr),
                  0, &RedirectHandle_t_Dictionary, isa_proxy, 0,
                  sizeof(::RedirectHandle_t) );
      instance.SetNew(&new_RedirectHandle_t);
      instance.SetNewArray(&newArray_RedirectHandle_t);
      instance.SetDelete(&delete_RedirectHandle_t);
      instance.SetDeleteArray(&deleteArray_RedirectHandle_t);
      instance.SetDestructor(&destruct_RedirectHandle_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RedirectHandle_t*)
   {
      return GenerateInitInstanceLocal((::RedirectHandle_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RedirectHandle_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RedirectHandle_t_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::RedirectHandle_t*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TProcessEventTimer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TProcessEventTimer(void *p);
   static void deleteArray_TProcessEventTimer(void *p);
   static void destruct_TProcessEventTimer(void *p);
   static void streamer_TProcessEventTimer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProcessEventTimer*)
   {
      ::TProcessEventTimer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProcessEventTimer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TProcessEventTimer", ::TProcessEventTimer::Class_Version(), "include/TSystem.h", 253,
                  typeid(::TProcessEventTimer), DefineBehavior(ptr, ptr),
                  &::TProcessEventTimer::Dictionary, isa_proxy, 0,
                  sizeof(::TProcessEventTimer) );
      instance.SetDelete(&delete_TProcessEventTimer);
      instance.SetDeleteArray(&deleteArray_TProcessEventTimer);
      instance.SetDestructor(&destruct_TProcessEventTimer);
      instance.SetStreamerFunc(&streamer_TProcessEventTimer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TProcessEventTimer*)
   {
      return GenerateInitInstanceLocal((::TProcessEventTimer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProcessEventTimer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRemoteObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRemoteObject(void *p = 0);
   static void *newArray_TRemoteObject(Long_t size, void *p);
   static void delete_TRemoteObject(void *p);
   static void deleteArray_TRemoteObject(void *p);
   static void destruct_TRemoteObject(void *p);
   static void streamer_TRemoteObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRemoteObject*)
   {
      ::TRemoteObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRemoteObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRemoteObject", ::TRemoteObject::Class_Version(), "include/TRemoteObject.h", 42,
                  typeid(::TRemoteObject), DefineBehavior(ptr, ptr),
                  &::TRemoteObject::Dictionary, isa_proxy, 1,
                  sizeof(::TRemoteObject) );
      instance.SetNew(&new_TRemoteObject);
      instance.SetNewArray(&newArray_TRemoteObject);
      instance.SetDelete(&delete_TRemoteObject);
      instance.SetDeleteArray(&deleteArray_TRemoteObject);
      instance.SetDestructor(&destruct_TRemoteObject);
      instance.SetStreamerFunc(&streamer_TRemoteObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRemoteObject*)
   {
      return GenerateInitInstanceLocal((::TRemoteObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRemoteObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TROOT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TROOT(void *p);
   static void deleteArray_TROOT(void *p);
   static void destruct_TROOT(void *p);
   static void streamer_TROOT(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TROOT*)
   {
      ::TROOT *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TROOT >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TROOT", ::TROOT::Class_Version(), "include/TROOT.h", 57,
                  typeid(::TROOT), DefineBehavior(ptr, ptr),
                  &::TROOT::Dictionary, isa_proxy, 0,
                  sizeof(::TROOT) );
      instance.SetDelete(&delete_TROOT);
      instance.SetDeleteArray(&deleteArray_TROOT);
      instance.SetDestructor(&destruct_TROOT);
      instance.SetStreamerFunc(&streamer_TROOT);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TROOT*)
   {
      return GenerateInitInstanceLocal((::TROOT*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TROOT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTask_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTask(void *p = 0);
   static void *newArray_TTask(Long_t size, void *p);
   static void delete_TTask(void *p);
   static void deleteArray_TTask(void *p);
   static void destruct_TTask(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTask*)
   {
      ::TTask *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTask >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTask", ::TTask::Class_Version(), "include/TTask.h", 34,
                  typeid(::TTask), DefineBehavior(ptr, ptr),
                  &::TTask::Dictionary, isa_proxy, 4,
                  sizeof(::TTask) );
      instance.SetNew(&new_TTask);
      instance.SetNewArray(&newArray_TTask);
      instance.SetDelete(&delete_TTask);
      instance.SetDeleteArray(&deleteArray_TTask);
      instance.SetDestructor(&destruct_TTask);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTask*)
   {
      return GenerateInitInstanceLocal((::TTask*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTask*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator_Dictionary();
   static void *new_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p = 0);
   static void *newArray_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(Long_t size, void *p);
   static void delete_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p);
   static void deleteArray_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p);
   static void destruct_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::vector<string,allocator<string> >::iterator*)
   {
      ::vector<string,allocator<string> >::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::vector<string,allocator<string> >::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<string,allocator<string> >::iterator", "prec_stl/vector", 218,
                  typeid(::vector<string,allocator<string> >::iterator), DefineBehavior(ptr, ptr),
                  0, &vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::vector<string,allocator<string> >::iterator) );
      instance.SetNew(&new_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator);
      instance.SetNewArray(&newArray_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator);
      instance.SetDelete(&delete_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator);
      instance.SetDeleteArray(&deleteArray_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator);
      instance.SetDestructor(&destruct_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::vector<string,allocator<string> >::iterator*)
   {
      return GenerateInitInstanceLocal((::vector<string,allocator<string> >::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::vector<string,allocator<string> >::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::vector<string,allocator<string> >::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR_Dictionary();
   static void *new_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p = 0);
   static void *newArray_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(Long_t size, void *p);
   static void delete_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p);
   static void deleteArray_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p);
   static void destruct_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::reverse_iterator<vector<string,allocator<string> >::iterator>*)
   {
      ::reverse_iterator<vector<string,allocator<string> >::iterator> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::reverse_iterator<vector<string,allocator<string> >::iterator>),0);
      static ::ROOT::TGenericClassInfo 
         instance("reverse_iterator<vector<string,allocator<string> >::iterator>", "prec_stl/iterator", 166,
                  typeid(::reverse_iterator<vector<string,allocator<string> >::iterator>), DefineBehavior(ptr, ptr),
                  0, &reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR_Dictionary, isa_proxy, 0,
                  sizeof(::reverse_iterator<vector<string,allocator<string> >::iterator>) );
      instance.SetNew(&new_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
      instance.SetNewArray(&newArray_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
      instance.SetDelete(&delete_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
      instance.SetDeleteArray(&deleteArray_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
      instance.SetDestructor(&destruct_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::reverse_iterator<vector<string,allocator<string> >::iterator>*)
   {
      return GenerateInitInstanceLocal((::reverse_iterator<vector<string,allocator<string> >::iterator>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::reverse_iterator<vector<string,allocator<string> >::iterator>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::reverse_iterator<vector<string,allocator<string> >::iterator>*)0x0)->GetClass();
   }

} // end of namespace ROOT

//______________________________________________________________________________
TClass *TMemberInspector::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TMemberInspector::Class_Name()
{
   return "TMemberInspector";
}

//______________________________________________________________________________
const char *TMemberInspector::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMemberInspector*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMemberInspector::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMemberInspector*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TMemberInspector::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMemberInspector*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TMemberInspector::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMemberInspector*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TObject::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TObject::Class_Name()
{
   return "TObject";
}

//______________________________________________________________________________
const char *TObject::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TObject*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TObject::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TObject*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TObject::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TObject*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TObject::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TObject*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TNamed::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TNamed::Class_Name()
{
   return "TNamed";
}

//______________________________________________________________________________
const char *TNamed::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TNamed*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TNamed::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TNamed*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TNamed::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNamed*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TNamed::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNamed*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TString::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TString::Class_Name()
{
   return "TString";
}

//______________________________________________________________________________
const char *TString::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TString*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TString::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TString*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TString::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TString*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TString::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TString*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TStorage::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TStorage::Class_Name()
{
   return "TStorage";
}

//______________________________________________________________________________
const char *TStorage::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStorage*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TStorage::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStorage*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TStorage::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStorage*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TStorage::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStorage*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TTimer::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TTimer::Class_Name()
{
   return "TTimer";
}

//______________________________________________________________________________
const char *TTimer::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTimer*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TTimer::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTimer*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TTimer::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTimer*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TTimer::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTimer*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TProcessID::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TProcessID::Class_Name()
{
   return "TProcessID";
}

//______________________________________________________________________________
const char *TProcessID::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TProcessID*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TProcessID::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TProcessID*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TProcessID::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProcessID*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TProcessID::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProcessID*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TRegexp::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TRegexp::Class_Name()
{
   return "TRegexp";
}

//______________________________________________________________________________
const char *TRegexp::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRegexp*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TRegexp::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRegexp*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TRegexp::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRegexp*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TRegexp::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRegexp*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TPRegexp::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TPRegexp::Class_Name()
{
   return "TPRegexp";
}

//______________________________________________________________________________
const char *TPRegexp::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPRegexp*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TPRegexp::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPRegexp*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TPRegexp::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPRegexp*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TPRegexp::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPRegexp*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TStringLong::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TStringLong::Class_Name()
{
   return "TStringLong";
}

//______________________________________________________________________________
const char *TStringLong::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStringLong*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TStringLong::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStringLong*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TStringLong::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStringLong*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TStringLong::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStringLong*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TQConnection::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TQConnection::Class_Name()
{
   return "TQConnection";
}

//______________________________________________________________________________
const char *TQConnection::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQConnection*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TQConnection::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQConnection*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TQConnection::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQConnection*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TQConnection::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQConnection*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TQObject::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TQObject::Class_Name()
{
   return "TQObject";
}

//______________________________________________________________________________
const char *TQObject::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQObject*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TQObject::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQObject*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TQObject::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQObject*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TQObject::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQObject*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TQObjSender::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TQObjSender::Class_Name()
{
   return "TQObjSender";
}

//______________________________________________________________________________
const char *TQObjSender::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQObjSender*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TQObjSender::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQObjSender*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TQObjSender::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQObjSender*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TQObjSender::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQObjSender*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TSignalHandler::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TSignalHandler::Class_Name()
{
   return "TSignalHandler";
}

//______________________________________________________________________________
const char *TSignalHandler::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSignalHandler*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TSignalHandler::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSignalHandler*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TSignalHandler::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSignalHandler*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TSignalHandler::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSignalHandler*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TStopwatch::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TStopwatch::Class_Name()
{
   return "TStopwatch";
}

//______________________________________________________________________________
const char *TStopwatch::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStopwatch*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TStopwatch::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStopwatch*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TStopwatch::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStopwatch*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TStopwatch::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStopwatch*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TUUID::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TUUID::Class_Name()
{
   return "TUUID";
}

//______________________________________________________________________________
const char *TUUID::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TUUID*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TUUID::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TUUID*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TUUID::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TUUID*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TUUID::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TUUID*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TExec::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TExec::Class_Name()
{
   return "TExec";
}

//______________________________________________________________________________
const char *TExec::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TExec*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TExec::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TExec*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TExec::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExec*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TExec::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExec*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TFolder::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TFolder::Class_Name()
{
   return "TFolder";
}

//______________________________________________________________________________
const char *TFolder::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TFolder*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TFolder::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TFolder*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TFolder::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFolder*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TFolder::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFolder*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TObjString::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TObjString::Class_Name()
{
   return "TObjString";
}

//______________________________________________________________________________
const char *TObjString::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TObjString*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TObjString::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TObjString*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TObjString::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TObjString*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TObjString::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TObjString*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TMD5::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TMD5::Class_Name()
{
   return "TMD5";
}

//______________________________________________________________________________
const char *TMD5::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMD5*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMD5::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMD5*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TMD5::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMD5*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TMD5::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMD5*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TMacro::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TMacro::Class_Name()
{
   return "TMacro";
}

//______________________________________________________________________________
const char *TMacro::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMacro*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMacro::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMacro*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TMacro::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMacro*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TMacro::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMacro*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TMessageHandler::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TMessageHandler::Class_Name()
{
   return "TMessageHandler";
}

//______________________________________________________________________________
const char *TMessageHandler::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMessageHandler*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMessageHandler::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMessageHandler*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TMessageHandler::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMessageHandler*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TMessageHandler::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMessageHandler*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TPluginManager::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TPluginManager::Class_Name()
{
   return "TPluginManager";
}

//______________________________________________________________________________
const char *TPluginManager::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPluginManager*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TPluginManager::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPluginManager*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TPluginManager::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPluginManager*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TPluginManager::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPluginManager*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TPluginHandler::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TPluginHandler::Class_Name()
{
   return "TPluginHandler";
}

//______________________________________________________________________________
const char *TPluginHandler::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPluginHandler*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TPluginHandler::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPluginHandler*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TPluginHandler::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPluginHandler*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TPluginHandler::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPluginHandler*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TPMERegexp::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TPMERegexp::Class_Name()
{
   return "TPMERegexp";
}

//______________________________________________________________________________
const char *TPMERegexp::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPMERegexp*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TPMERegexp::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TPMERegexp*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TPMERegexp::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPMERegexp*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TPMERegexp::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPMERegexp*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TStringToken::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TStringToken::Class_Name()
{
   return "TStringToken";
}

//______________________________________________________________________________
const char *TStringToken::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStringToken*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TStringToken::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStringToken*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TStringToken::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStringToken*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TStringToken::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStringToken*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TProcessUUID::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TProcessUUID::Class_Name()
{
   return "TProcessUUID";
}

//______________________________________________________________________________
const char *TProcessUUID::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TProcessUUID*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TProcessUUID::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TProcessUUID*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TProcessUUID::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProcessUUID*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TProcessUUID::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProcessUUID*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TQClass::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TQClass::Class_Name()
{
   return "TQClass";
}

//______________________________________________________________________________
const char *TQClass::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQClass*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TQClass::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQClass*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TQClass::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQClass*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TQClass::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQClass*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TQCommand::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TQCommand::Class_Name()
{
   return "TQCommand";
}

//______________________________________________________________________________
const char *TQCommand::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQCommand*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TQCommand::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQCommand*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TQCommand::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQCommand*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TQCommand::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQCommand*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TQUndoManager::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TQUndoManager::Class_Name()
{
   return "TQUndoManager";
}

//______________________________________________________________________________
const char *TQUndoManager::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQUndoManager*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TQUndoManager::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TQUndoManager*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TQUndoManager::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQUndoManager*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TQUndoManager::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQUndoManager*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TRef::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TRef::Class_Name()
{
   return "TRef";
}

//______________________________________________________________________________
const char *TRef::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRef*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TRef::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRef*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TRef::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRef*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TRef::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRef*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TSystemFile::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TSystemFile::Class_Name()
{
   return "TSystemFile";
}

//______________________________________________________________________________
const char *TSystemFile::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSystemFile*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TSystemFile::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSystemFile*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TSystemFile::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSystemFile*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TSystemFile::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSystemFile*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TSystemDirectory::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TSystemDirectory::Class_Name()
{
   return "TSystemDirectory";
}

//______________________________________________________________________________
const char *TSystemDirectory::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSystemDirectory*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TSystemDirectory::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSystemDirectory*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TSystemDirectory::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSystemDirectory*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TSystemDirectory::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSystemDirectory*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TSystem::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TSystem::Class_Name()
{
   return "TSystem";
}

//______________________________________________________________________________
const char *TSystem::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSystem*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TSystem::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSystem*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TSystem::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSystem*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TSystem::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSystem*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TSysEvtHandler::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TSysEvtHandler::Class_Name()
{
   return "TSysEvtHandler";
}

//______________________________________________________________________________
const char *TSysEvtHandler::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSysEvtHandler*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TSysEvtHandler::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TSysEvtHandler*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TSysEvtHandler::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSysEvtHandler*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TSysEvtHandler::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSysEvtHandler*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TStdExceptionHandler::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TStdExceptionHandler::Class_Name()
{
   return "TStdExceptionHandler";
}

//______________________________________________________________________________
const char *TStdExceptionHandler::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStdExceptionHandler*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TStdExceptionHandler::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TStdExceptionHandler*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TStdExceptionHandler::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStdExceptionHandler*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TStdExceptionHandler::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStdExceptionHandler*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TTime::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TTime::Class_Name()
{
   return "TTime";
}

//______________________________________________________________________________
const char *TTime::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTime*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TTime::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTime*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TTime::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTime*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TTime::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTime*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *SysInfo_t::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *SysInfo_t::Class_Name()
{
   return "SysInfo_t";
}

//______________________________________________________________________________
const char *SysInfo_t::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::SysInfo_t*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SysInfo_t::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::SysInfo_t*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SysInfo_t::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::SysInfo_t*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SysInfo_t::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::SysInfo_t*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *CpuInfo_t::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *CpuInfo_t::Class_Name()
{
   return "CpuInfo_t";
}

//______________________________________________________________________________
const char *CpuInfo_t::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::CpuInfo_t*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int CpuInfo_t::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::CpuInfo_t*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void CpuInfo_t::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CpuInfo_t*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *CpuInfo_t::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CpuInfo_t*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *MemInfo_t::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *MemInfo_t::Class_Name()
{
   return "MemInfo_t";
}

//______________________________________________________________________________
const char *MemInfo_t::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::MemInfo_t*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MemInfo_t::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::MemInfo_t*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MemInfo_t::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MemInfo_t*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MemInfo_t::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MemInfo_t*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *ProcInfo_t::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *ProcInfo_t::Class_Name()
{
   return "ProcInfo_t";
}

//______________________________________________________________________________
const char *ProcInfo_t::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::ProcInfo_t*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ProcInfo_t::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::ProcInfo_t*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void ProcInfo_t::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ProcInfo_t*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *ProcInfo_t::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ProcInfo_t*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TProcessEventTimer::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TProcessEventTimer::Class_Name()
{
   return "TProcessEventTimer";
}

//______________________________________________________________________________
const char *TProcessEventTimer::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TProcessEventTimer*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TProcessEventTimer::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TProcessEventTimer*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TProcessEventTimer::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProcessEventTimer*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TProcessEventTimer::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProcessEventTimer*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TRemoteObject::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TRemoteObject::Class_Name()
{
   return "TRemoteObject";
}

//______________________________________________________________________________
const char *TRemoteObject::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRemoteObject*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TRemoteObject::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRemoteObject*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TRemoteObject::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRemoteObject*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TRemoteObject::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRemoteObject*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TROOT::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TROOT::Class_Name()
{
   return "TROOT";
}

//______________________________________________________________________________
const char *TROOT::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TROOT*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TROOT::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TROOT*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TROOT::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TROOT*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TROOT::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TROOT*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TTask::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TTask::Class_Name()
{
   return "TTask";
}

//______________________________________________________________________________
const char *TTask::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTask*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TTask::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTask*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TTask::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTask*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TTask::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTask*)0x0)->GetClass();
   return fgIsA;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_string(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) string : new string;
   }
   static void *newArray_string(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) string[nElements] : new string[nElements];
   }
   // Wrapper around operator delete
   static void delete_string(void *p) {
      delete ((string*)p);
   }
   static void deleteArray_string(void *p) {
      delete [] ((string*)p);
   }
   static void destruct_string(void *p) {
      typedef string current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class string

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<string,allocator<string> >::iterator : new ::vector<string,allocator<string> >::iterator;
   }
   static void *newArray_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<string,allocator<string> >::iterator[nElements] : new ::vector<string,allocator<string> >::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p) {
      delete ((::vector<string,allocator<string> >::iterator*)p);
   }
   static void deleteArray_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p) {
      delete [] ((::vector<string,allocator<string> >::iterator*)p);
   }
   static void destruct_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void *p) {
      typedef ::vector<string,allocator<string> >::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::vector<string,allocator<string> >::iterator

namespace ROOT {
   // Wrappers around operator new
   static void *new_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::reverse_iterator<vector<string,allocator<string> >::iterator> : new ::reverse_iterator<vector<string,allocator<string> >::iterator>;
   }
   static void *newArray_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::reverse_iterator<vector<string,allocator<string> >::iterator>[nElements] : new ::reverse_iterator<vector<string,allocator<string> >::iterator>[nElements];
   }
   // Wrapper around operator delete
   static void delete_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p) {
      delete ((::reverse_iterator<vector<string,allocator<string> >::iterator>*)p);
   }
   static void deleteArray_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p) {
      delete [] ((::reverse_iterator<vector<string,allocator<string> >::iterator>*)p);
   }
   static void destruct_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void *p) {
      typedef ::reverse_iterator<vector<string,allocator<string> >::iterator> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::reverse_iterator<vector<string,allocator<string> >::iterator>

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<TString,allocator<TString> >::iterator : new ::vector<TString,allocator<TString> >::iterator;
   }
   static void *newArray_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<TString,allocator<TString> >::iterator[nElements] : new ::vector<TString,allocator<TString> >::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p) {
      delete ((::vector<TString,allocator<TString> >::iterator*)p);
   }
   static void deleteArray_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p) {
      delete [] ((::vector<TString,allocator<TString> >::iterator*)p);
   }
   static void destruct_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void *p) {
      typedef ::vector<TString,allocator<TString> >::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::vector<TString,allocator<TString> >::iterator

namespace ROOT {
   // Wrappers around operator new
   static void *new_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::reverse_iterator<vector<TString,allocator<TString> >::iterator> : new ::reverse_iterator<vector<TString,allocator<TString> >::iterator>;
   }
   static void *newArray_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::reverse_iterator<vector<TString,allocator<TString> >::iterator>[nElements] : new ::reverse_iterator<vector<TString,allocator<TString> >::iterator>[nElements];
   }
   // Wrapper around operator delete
   static void delete_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p) {
      delete ((::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)p);
   }
   static void deleteArray_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p) {
      delete [] ((::reverse_iterator<vector<TString,allocator<TString> >::iterator>*)p);
   }
   static void destruct_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void *p) {
      typedef ::reverse_iterator<vector<TString,allocator<TString> >::iterator> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::reverse_iterator<vector<TString,allocator<TString> >::iterator>

//______________________________________________________________________________
void TExec::Streamer(TBuffer &R__b)
{
   // Stream an object of class TExec.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TExec::Class(),this);
   } else {
      R__b.WriteClassBuffer(TExec::Class(),this);
   }
}

//______________________________________________________________________________
void TExec::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TExec.
      TClass *R__cl = ::TExec::IsA();
      if (R__cl || R__insp.IsA()) { }
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TExec(void *p) {
      return  p ? new(p) ::TExec : new ::TExec;
   }
   static void *newArray_TExec(Long_t nElements, void *p) {
      return p ? new(p) ::TExec[nElements] : new ::TExec[nElements];
   }
   // Wrapper around operator delete
   static void delete_TExec(void *p) {
      delete ((::TExec*)p);
   }
   static void deleteArray_TExec(void *p) {
      delete [] ((::TExec*)p);
   }
   static void destruct_TExec(void *p) {
      typedef ::TExec current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TExec

//______________________________________________________________________________
void TFolder::Streamer(TBuffer &R__b)
{
   // Stream an object of class TFolder.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TFolder::Class(),this);
   } else {
      R__b.WriteClassBuffer(TFolder::Class(),this);
   }
}

//______________________________________________________________________________
void TFolder::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFolder.
      TClass *R__cl = ::TFolder::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFolders", &fFolders);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOwner", &fIsOwner);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFolder(void *p) {
      return  p ? new(p) ::TFolder : new ::TFolder;
   }
   static void *newArray_TFolder(Long_t nElements, void *p) {
      return p ? new(p) ::TFolder[nElements] : new ::TFolder[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFolder(void *p) {
      delete ((::TFolder*)p);
   }
   static void deleteArray_TFolder(void *p) {
      delete [] ((::TFolder*)p);
   }
   static void destruct_TFolder(void *p) {
      typedef ::TFolder current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFolder

//______________________________________________________________________________
void TMacro::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMacro.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMacro::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMacro::Class(),this);
   }
}

//______________________________________________________________________________
void TMacro::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMacro.
      TClass *R__cl = ::TMacro::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLines", &fLines);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParams", &fParams);
      R__insp.InspectMember(fParams, "fParams.");
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMacro(void *p) {
      return  p ? new(p) ::TMacro : new ::TMacro;
   }
   static void *newArray_TMacro(Long_t nElements, void *p) {
      return p ? new(p) ::TMacro[nElements] : new ::TMacro[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMacro(void *p) {
      delete ((::TMacro*)p);
   }
   static void deleteArray_TMacro(void *p) {
      delete [] ((::TMacro*)p);
   }
   static void destruct_TMacro(void *p) {
      typedef ::TMacro current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMacro

//______________________________________________________________________________
void TMD5::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMD5.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMD5::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMD5::Class(),this);
   }
}

//______________________________________________________________________________
void TMD5::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMD5.
      TClass *R__cl = ::TMD5::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuf[4]", fBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBits[2]", fBits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIn[64]", fIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDigest[16]", fDigest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFinalized", &fFinalized);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMD5(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMD5 : new ::TMD5;
   }
   static void *newArray_TMD5(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMD5[nElements] : new ::TMD5[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMD5(void *p) {
      delete ((::TMD5*)p);
   }
   static void deleteArray_TMD5(void *p) {
      delete [] ((::TMD5*)p);
   }
   static void destruct_TMD5(void *p) {
      typedef ::TMD5 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMD5

//______________________________________________________________________________
void TMemberInspector::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMemberInspector.

   ::Error("TMemberInspector::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TMemberInspector::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMemberInspector.
      TClass *R__cl = ::TMemberInspector::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMemberInspector(void *p) {
      delete ((::TMemberInspector*)p);
   }
   static void deleteArray_TMemberInspector(void *p) {
      delete [] ((::TMemberInspector*)p);
   }
   static void destruct_TMemberInspector(void *p) {
      typedef ::TMemberInspector current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMemberInspector(TBuffer &buf, void *obj) {
      ((::TMemberInspector*)obj)->::TMemberInspector::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMemberInspector

//______________________________________________________________________________
void TMessageHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMessageHandler.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMessageHandler::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMessageHandler::Class(),this);
   }
}

//______________________________________________________________________________
void TMessageHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMessageHandler.
      TClass *R__cl = ::TMessageHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMessObj", &fMessObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMessId", &fMessId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCnts", &fCnts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMessIds", &fMessIds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDerived", &fDerived);
      TNamed::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMessageHandler(void *p) {
      delete ((::TMessageHandler*)p);
   }
   static void deleteArray_TMessageHandler(void *p) {
      delete [] ((::TMessageHandler*)p);
   }
   static void destruct_TMessageHandler(void *p) {
      typedef ::TMessageHandler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMessageHandler

//______________________________________________________________________________
void TNamed::Streamer(TBuffer &R__b)
{
   // Stream an object of class TNamed.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TNamed::Class(),this);
   } else {
      R__b.WriteClassBuffer(TNamed::Class(),this);
   }
}

//______________________________________________________________________________
void TNamed::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNamed.
      TClass *R__cl = ::TNamed::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
      R__insp.InspectMember(fTitle, "fTitle.");
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TNamed(void *p) {
      return  p ? new(p) ::TNamed : new ::TNamed;
   }
   static void *newArray_TNamed(Long_t nElements, void *p) {
      return p ? new(p) ::TNamed[nElements] : new ::TNamed[nElements];
   }
   // Wrapper around operator delete
   static void delete_TNamed(void *p) {
      delete ((::TNamed*)p);
   }
   static void deleteArray_TNamed(void *p) {
      delete [] ((::TNamed*)p);
   }
   static void destruct_TNamed(void *p) {
      typedef ::TNamed current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TNamed

//______________________________________________________________________________
void TObjString::Streamer(TBuffer &R__b)
{
   // Stream an object of class TObjString.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TObjString::Class(),this);
   } else {
      R__b.WriteClassBuffer(TObjString::Class(),this);
   }
}

//______________________________________________________________________________
void TObjString::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TObjString.
      TClass *R__cl = ::TObjString::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fString", &fString);
      R__insp.InspectMember(fString, "fString.");
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TObjString(void *p) {
      return  p ? new(p) ::TObjString : new ::TObjString;
   }
   static void *newArray_TObjString(Long_t nElements, void *p) {
      return p ? new(p) ::TObjString[nElements] : new ::TObjString[nElements];
   }
   // Wrapper around operator delete
   static void delete_TObjString(void *p) {
      delete ((::TObjString*)p);
   }
   static void deleteArray_TObjString(void *p) {
      delete [] ((::TObjString*)p);
   }
   static void destruct_TObjString(void *p) {
      typedef ::TObjString current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TObjString

//______________________________________________________________________________
void TObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TObject.
      TClass *R__cl = ::TObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUniqueID", &fUniqueID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBits", &fBits);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TObject(void *p) {
      return  p ? new(p) ::TObject : new ::TObject;
   }
   static void *newArray_TObject(Long_t nElements, void *p) {
      return p ? new(p) ::TObject[nElements] : new ::TObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TObject(void *p) {
      delete ((::TObject*)p);
   }
   static void deleteArray_TObject(void *p) {
      delete [] ((::TObject*)p);
   }
   static void destruct_TObject(void *p) {
      typedef ::TObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TObject(TBuffer &buf, void *obj) {
      ((::TObject*)obj)->::TObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TObject

//______________________________________________________________________________
void TRemoteObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRemoteObject.
      TClass *R__cl = ::TRemoteObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileStat", (void*)&fFileStat);
      R__insp.InspectMember("FileStat_t", (void*)&fFileStat, "fFileStat.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsFolder", &fIsFolder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRemoteAddress", &fRemoteAddress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeyObjectName", &fKeyObjectName);
      R__insp.InspectMember(fKeyObjectName, "fKeyObjectName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeyClassName", &fKeyClassName);
      R__insp.InspectMember(fKeyClassName, "fKeyClassName.");
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRemoteObject(void *p) {
      return  p ? new(p) ::TRemoteObject : new ::TRemoteObject;
   }
   static void *newArray_TRemoteObject(Long_t nElements, void *p) {
      return p ? new(p) ::TRemoteObject[nElements] : new ::TRemoteObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRemoteObject(void *p) {
      delete ((::TRemoteObject*)p);
   }
   static void deleteArray_TRemoteObject(void *p) {
      delete [] ((::TRemoteObject*)p);
   }
   static void destruct_TRemoteObject(void *p) {
      typedef ::TRemoteObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRemoteObject(TBuffer &buf, void *obj) {
      ((::TRemoteObject*)obj)->::TRemoteObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRemoteObject

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPoint(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPoint : new ::TPoint;
   }
   static void *newArray_TPoint(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPoint[nElements] : new ::TPoint[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPoint(void *p) {
      delete ((::TPoint*)p);
   }
   static void deleteArray_TPoint(void *p) {
      delete [] ((::TPoint*)p);
   }
   static void destruct_TPoint(void *p) {
      typedef ::TPoint current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPoint

//______________________________________________________________________________
void TProcessID::Streamer(TBuffer &R__b)
{
   // Stream an object of class TProcessID.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TProcessID::Class(),this);
   } else {
      R__b.WriteClassBuffer(TProcessID::Class(),this);
   }
}

//______________________________________________________________________________
void TProcessID::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProcessID.
      TClass *R__cl = ::TProcessID::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCount", &fCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjects", &fObjects);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProcessID(void *p) {
      return  p ? new(p) ::TProcessID : new ::TProcessID;
   }
   static void *newArray_TProcessID(Long_t nElements, void *p) {
      return p ? new(p) ::TProcessID[nElements] : new ::TProcessID[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProcessID(void *p) {
      delete ((::TProcessID*)p);
   }
   static void deleteArray_TProcessID(void *p) {
      delete [] ((::TProcessID*)p);
   }
   static void destruct_TProcessID(void *p) {
      typedef ::TProcessID current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProcessID

//______________________________________________________________________________
void TProcessUUID::Streamer(TBuffer &R__b)
{
   // Stream an object of class TProcessUUID.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TProcessUUID::Class(),this);
   } else {
      R__b.WriteClassBuffer(TProcessUUID::Class(),this);
   }
}

//______________________________________________________________________________
void TProcessUUID::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProcessUUID.
      TClass *R__cl = ::TProcessUUID::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUUIDs", &fUUIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
      TProcessID::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProcessUUID(void *p) {
      return  p ? new(p) ::TProcessUUID : new ::TProcessUUID;
   }
   static void *newArray_TProcessUUID(Long_t nElements, void *p) {
      return p ? new(p) ::TProcessUUID[nElements] : new ::TProcessUUID[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProcessUUID(void *p) {
      delete ((::TProcessUUID*)p);
   }
   static void deleteArray_TProcessUUID(void *p) {
      delete [] ((::TProcessUUID*)p);
   }
   static void destruct_TProcessUUID(void *p) {
      typedef ::TProcessUUID current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TProcessUUID

//______________________________________________________________________________
void TProcessEventTimer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TProcessEventTimer.

   TTimer::Streamer(R__b);
}

//______________________________________________________________________________
void TProcessEventTimer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProcessEventTimer.
      TClass *R__cl = ::TProcessEventTimer::IsA();
      if (R__cl || R__insp.IsA()) { }
      TTimer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TProcessEventTimer(void *p) {
      delete ((::TProcessEventTimer*)p);
   }
   static void deleteArray_TProcessEventTimer(void *p) {
      delete [] ((::TProcessEventTimer*)p);
   }
   static void destruct_TProcessEventTimer(void *p) {
      typedef ::TProcessEventTimer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TProcessEventTimer(TBuffer &buf, void *obj) {
      ((::TProcessEventTimer*)obj)->::TProcessEventTimer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TProcessEventTimer

//______________________________________________________________________________
void TRef::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRef.
      TClass *R__cl = ::TRef::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPID", &fPID);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRef(void *p) {
      return  p ? new(p) ::TRef : new ::TRef;
   }
   static void *newArray_TRef(Long_t nElements, void *p) {
      return p ? new(p) ::TRef[nElements] : new ::TRef[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRef(void *p) {
      delete ((::TRef*)p);
   }
   static void deleteArray_TRef(void *p) {
      delete [] ((::TRef*)p);
   }
   static void destruct_TRef(void *p) {
      typedef ::TRef current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRef(TBuffer &buf, void *obj) {
      ((::TRef*)obj)->::TRef::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRef

//______________________________________________________________________________
void TROOT::Streamer(TBuffer &R__b)
{
   // Stream an object of class TROOT.

   TDirectory::Streamer(R__b);
}

//______________________________________________________________________________
void TROOT::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TROOT.
      TClass *R__cl = ::TROOT::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineIsProcessing", &fLineIsProcessing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfigOptions", &fConfigOptions);
      R__insp.InspectMember(fConfigOptions, "fConfigOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfigFeatures", &fConfigFeatures);
      R__insp.InspectMember(fConfigFeatures, "fConfigFeatures.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersion", &fVersion);
      R__insp.InspectMember(fVersion, "fVersion.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersionInt", &fVersionInt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersionCode", &fVersionCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersionDate", &fVersionDate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVersionTime", &fVersionTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuiltDate", &fBuiltDate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuiltTime", &fBuiltTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSvnRevision", &fSvnRevision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSvnBranch", &fSvnBranch);
      R__insp.InspectMember(fSvnBranch, "fSvnBranch.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSvnDate", &fSvnDate);
      R__insp.InspectMember(fSvnDate, "fSvnDate.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimer", &fTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplication", &fApplication);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterpreter", &fInterpreter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBatch", &fBatch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditHistograms", &fEditHistograms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFromPopUp", &fFromPopUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMustClean", &fMustClean);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadingObject", &fReadingObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForceStyle", &fForceStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEscape", &fEscape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExecutingMacro", &fExecutingMacro);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditorMode", &fEditorMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrimitive", &fPrimitive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectPad", &fSelectPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClasses", &fClasses);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypes", &fTypes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobals", &fGlobals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalFunctions", &fGlobalFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFiles", &fFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMappedFiles", &fMappedFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSockets", &fSockets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvases", &fCanvases);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyles", &fStyles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctions", &fFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTasks", &fTasks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColors", &fColors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometries", &fGeometries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrowsers", &fBrowsers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSpecials", &fSpecials);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCleanups", &fCleanups);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMessageHandlers", &fMessageHandlers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStreamerInfo", &fStreamerInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClassGenerators", &fClassGenerators);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSecContexts", &fSecContexts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProofs", &fProofs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipboard", &fClipboard);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSets", &fDataSets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUUIDs", &fUUIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRootFolder", &fRootFolder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrowsables", &fBrowsables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPluginManager", &fPluginManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutClassName", &fCutClassName);
      R__insp.InspectMember(fCutClassName, "fCutClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefCanvasName", &fDefCanvasName);
      R__insp.InspectMember(fDefCanvasName, "fDefCanvasName.");
      TDirectory::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TROOT(void *p) {
      delete ((::TROOT*)p);
   }
   static void deleteArray_TROOT(void *p) {
      delete [] ((::TROOT*)p);
   }
   static void destruct_TROOT(void *p) {
      typedef ::TROOT current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TROOT(TBuffer &buf, void *obj) {
      ((::TROOT*)obj)->::TROOT::Streamer(buf);
   }
} // end of namespace ROOT for class ::TROOT

//______________________________________________________________________________
void TRegexp::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRegexp.

   ::Error("TRegexp::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TRegexp::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRegexp.
      TClass *R__cl = ::TRegexp::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPattern", &fPattern);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStat", &fStat);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TRegexp(void *p) {
      delete ((::TRegexp*)p);
   }
   static void deleteArray_TRegexp(void *p) {
      delete [] ((::TRegexp*)p);
   }
   static void destruct_TRegexp(void *p) {
      typedef ::TRegexp current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRegexp(TBuffer &buf, void *obj) {
      ((::TRegexp*)obj)->::TRegexp::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRegexp

//______________________________________________________________________________
void TPRegexp::Streamer(TBuffer &R__b)
{
   // Stream an object of class TPRegexp.

   ::Error("TPRegexp::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TPRegexp::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPRegexp.
      TClass *R__cl = ::TPRegexp::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPattern", &fPattern);
      R__insp.InspectMember(fPattern, "fPattern.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriv", &fPriv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPCREOpts", &fPCREOpts);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPRegexp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPRegexp : new ::TPRegexp;
   }
   static void *newArray_TPRegexp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPRegexp[nElements] : new ::TPRegexp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPRegexp(void *p) {
      delete ((::TPRegexp*)p);
   }
   static void deleteArray_TPRegexp(void *p) {
      delete [] ((::TPRegexp*)p);
   }
   static void destruct_TPRegexp(void *p) {
      typedef ::TPRegexp current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPRegexp(TBuffer &buf, void *obj) {
      ((::TPRegexp*)obj)->::TPRegexp::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPRegexp

//______________________________________________________________________________
void TPMERegexp::Streamer(TBuffer &R__b)
{
   // Stream an object of class TPMERegexp.

   TPRegexp::Streamer(R__b);
}

//______________________________________________________________________________
void TPMERegexp::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPMERegexp.
      TClass *R__cl = ::TPMERegexp::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMaxMatches", &fNMaxMatches);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMatches", &fNMatches);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkers", &fMarkers);
      R__insp.InspectMember(fMarkers, "fMarkers.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastStringMatched", &fLastStringMatched);
      R__insp.InspectMember(fLastStringMatched, "fLastStringMatched.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddressOfLastString", &fAddressOfLastString);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastGlobalPosition", &fLastGlobalPosition);
      TPRegexp::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPMERegexp(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPMERegexp : new ::TPMERegexp;
   }
   static void *newArray_TPMERegexp(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPMERegexp[nElements] : new ::TPMERegexp[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPMERegexp(void *p) {
      delete ((::TPMERegexp*)p);
   }
   static void deleteArray_TPMERegexp(void *p) {
      delete [] ((::TPMERegexp*)p);
   }
   static void destruct_TPMERegexp(void *p) {
      typedef ::TPMERegexp current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPMERegexp(TBuffer &buf, void *obj) {
      ((::TPMERegexp*)obj)->::TPMERegexp::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPMERegexp

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRefCnt(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TRefCnt : new ::TRefCnt;
   }
   static void *newArray_TRefCnt(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TRefCnt[nElements] : new ::TRefCnt[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRefCnt(void *p) {
      delete ((::TRefCnt*)p);
   }
   static void deleteArray_TRefCnt(void *p) {
      delete [] ((::TRefCnt*)p);
   }
   static void destruct_TRefCnt(void *p) {
      typedef ::TRefCnt current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRefCnt

//______________________________________________________________________________
void TSignalHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TSignalHandler.

   TSysEvtHandler::Streamer(R__b);
}

//______________________________________________________________________________
void TSignalHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSignalHandler.
      TClass *R__cl = ::TSignalHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignal", &fSignal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSync", &fSync);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelay", &fDelay);
      TSysEvtHandler::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TSignalHandler(void *p) {
      delete ((::TSignalHandler*)p);
   }
   static void deleteArray_TSignalHandler(void *p) {
      delete [] ((::TSignalHandler*)p);
   }
   static void destruct_TSignalHandler(void *p) {
      typedef ::TSignalHandler current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSignalHandler(TBuffer &buf, void *obj) {
      ((::TSignalHandler*)obj)->::TSignalHandler::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSignalHandler

//______________________________________________________________________________
void TStdExceptionHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TStdExceptionHandler.

   TSysEvtHandler::Streamer(R__b);
}

//______________________________________________________________________________
void TStdExceptionHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStdExceptionHandler.
      TClass *R__cl = ::TStdExceptionHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      TSysEvtHandler::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TStdExceptionHandler(void *p) {
      delete ((::TStdExceptionHandler*)p);
   }
   static void deleteArray_TStdExceptionHandler(void *p) {
      delete [] ((::TStdExceptionHandler*)p);
   }
   static void destruct_TStdExceptionHandler(void *p) {
      typedef ::TStdExceptionHandler current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStdExceptionHandler(TBuffer &buf, void *obj) {
      ((::TStdExceptionHandler*)obj)->::TStdExceptionHandler::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStdExceptionHandler

//______________________________________________________________________________
void TStopwatch::Streamer(TBuffer &R__b)
{
   // Stream an object of class TStopwatch.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TStopwatch::Class(),this);
   } else {
      R__b.WriteClassBuffer(TStopwatch::Class(),this);
   }
}

//______________________________________________________________________________
void TStopwatch::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStopwatch.
      TClass *R__cl = ::TStopwatch::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartRealTime", &fStartRealTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStopRealTime", &fStopRealTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartCpuTime", &fStartCpuTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStopCpuTime", &fStopCpuTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalCpuTime", &fTotalCpuTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalRealTime", &fTotalRealTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCounter", &fCounter);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStopwatch(void *p) {
      return  p ? new(p) ::TStopwatch : new ::TStopwatch;
   }
   static void *newArray_TStopwatch(Long_t nElements, void *p) {
      return p ? new(p) ::TStopwatch[nElements] : new ::TStopwatch[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStopwatch(void *p) {
      delete ((::TStopwatch*)p);
   }
   static void deleteArray_TStopwatch(void *p) {
      delete [] ((::TStopwatch*)p);
   }
   static void destruct_TStopwatch(void *p) {
      typedef ::TStopwatch current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStopwatch

//______________________________________________________________________________
void TStorage::Streamer(TBuffer &R__b)
{
   // Stream an object of class TStorage.

   ::Error("TStorage::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TStorage::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStorage.
      TClass *R__cl = ::TStorage::IsA();
      if (R__cl || R__insp.IsA()) { }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStorage(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TStorage : new ::TStorage;
   }
   static void *newArray_TStorage(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TStorage[nElements] : new ::TStorage[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStorage(void *p) {
      delete ((::TStorage*)p);
   }
   static void deleteArray_TStorage(void *p) {
      delete [] ((::TStorage*)p);
   }
   static void destruct_TStorage(void *p) {
      typedef ::TStorage current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStorage(TBuffer &buf, void *obj) {
      ((::TStorage*)obj)->::TStorage::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStorage

//______________________________________________________________________________
void TString::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TString.
      TClass *R__cl = ::TString::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TString(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TString : new ::TString;
   }
   static void *newArray_TString(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TString[nElements] : new ::TString[nElements];
   }
   // Wrapper around operator delete
   static void delete_TString(void *p) {
      delete ((::TString*)p);
   }
   static void deleteArray_TString(void *p) {
      delete [] ((::TString*)p);
   }
   static void destruct_TString(void *p) {
      typedef ::TString current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TString(TBuffer &buf, void *obj) {
      ((::TString*)obj)->::TString::Streamer(buf);
   }
} // end of namespace ROOT for class ::TString

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStringRef(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TStringRef : new ::TStringRef;
   }
   static void *newArray_TStringRef(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TStringRef[nElements] : new ::TStringRef[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStringRef(void *p) {
      delete ((::TStringRef*)p);
   }
   static void deleteArray_TStringRef(void *p) {
      delete [] ((::TStringRef*)p);
   }
   static void destruct_TStringRef(void *p) {
      typedef ::TStringRef current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TStringRef

//______________________________________________________________________________
void TStringLong::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStringLong.
      TClass *R__cl = ::TStringLong::IsA();
      if (R__cl || R__insp.IsA()) { }
      TString::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TStringLong(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TStringLong : new ::TStringLong;
   }
   static void *newArray_TStringLong(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TStringLong[nElements] : new ::TStringLong[nElements];
   }
   // Wrapper around operator delete
   static void delete_TStringLong(void *p) {
      delete ((::TStringLong*)p);
   }
   static void deleteArray_TStringLong(void *p) {
      delete [] ((::TStringLong*)p);
   }
   static void destruct_TStringLong(void *p) {
      typedef ::TStringLong current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStringLong(TBuffer &buf, void *obj) {
      ((::TStringLong*)obj)->::TStringLong::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStringLong

//______________________________________________________________________________
void TStringToken::Streamer(TBuffer &R__b)
{
   // Stream an object of class TStringToken.

   TString::Streamer(R__b);
}

//______________________________________________________________________________
void TStringToken::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TStringToken.
      TClass *R__cl = ::TStringToken::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFullStr", &fFullStr);
      R__insp.InspectMember(const_cast<  TString &>( fFullStr ), "fFullStr.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSplitRe", &fSplitRe);
      R__insp.InspectMember(fSplitRe, "fSplitRe.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReturnVoid", &fReturnVoid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      TString::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TStringToken(void *p) {
      delete ((::TStringToken*)p);
   }
   static void deleteArray_TStringToken(void *p) {
      delete [] ((::TStringToken*)p);
   }
   static void destruct_TStringToken(void *p) {
      typedef ::TStringToken current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TStringToken(TBuffer &buf, void *obj) {
      ((::TStringToken*)obj)->::TStringToken::Streamer(buf);
   }
} // end of namespace ROOT for class ::TStringToken

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TSubString(void *p) {
      delete ((::TSubString*)p);
   }
   static void deleteArray_TSubString(void *p) {
      delete [] ((::TSubString*)p);
   }
   static void destruct_TSubString(void *p) {
      typedef ::TSubString current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSubString

//______________________________________________________________________________
void TSysEvtHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TSysEvtHandler.

   TObject::Streamer(R__b);
   TQObject::Streamer(R__b);
}

//______________________________________________________________________________
void TSysEvtHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSysEvtHandler.
      TClass *R__cl = ::TSysEvtHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsActive", &fIsActive);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TSysEvtHandler(void *p) {
      delete ((::TSysEvtHandler*)p);
   }
   static void deleteArray_TSysEvtHandler(void *p) {
      delete [] ((::TSysEvtHandler*)p);
   }
   static void destruct_TSysEvtHandler(void *p) {
      typedef ::TSysEvtHandler current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSysEvtHandler(TBuffer &buf, void *obj) {
      ((::TSysEvtHandler*)obj)->::TSysEvtHandler::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSysEvtHandler

//______________________________________________________________________________
void TSystem::Streamer(TBuffer &R__b)
{
   // Stream an object of class TSystem.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TSystem::Class(),this);
   } else {
      R__b.WriteClassBuffer(TSystem::Class(),this);
   }
}

//______________________________________________________________________________
void TSystem::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSystem.
      TClass *R__cl = ::TSystem::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadmask", &fReadmask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWritemask", &fWritemask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadready", &fReadready);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWriteready", &fWriteready);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSignals", &fSignals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNfd", &fNfd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxrfd", &fMaxrfd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxwfd", &fMaxwfd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigcnt", &fSigcnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWdpath", &fWdpath);
      R__insp.InspectMember(fWdpath, "fWdpath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHostname", &fHostname);
      R__insp.InspectMember(fHostname, "fHostname.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInsideNotify", &fInsideNotify);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeepFreq", &fBeepFreq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeepDuration", &fBeepDuration);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInControl", &fInControl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDone", &fDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastErrorString", &fLastErrorString);
      R__insp.InspectMember(fLastErrorString, "fLastErrorString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimers", &fTimers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSignalHandler", &fSignalHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileHandler", &fFileHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStdExceptionHandler", &fStdExceptionHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOnExitList", &fOnExitList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fListLibs", &fListLibs);
      R__insp.InspectMember(fListLibs, "fListLibs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuildArch", &fBuildArch);
      R__insp.InspectMember(fBuildArch, "fBuildArch.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuildCompiler", &fBuildCompiler);
      R__insp.InspectMember(fBuildCompiler, "fBuildCompiler.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuildCompilerVersion", &fBuildCompilerVersion);
      R__insp.InspectMember(fBuildCompilerVersion, "fBuildCompilerVersion.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuildNode", &fBuildNode);
      R__insp.InspectMember(fBuildNode, "fBuildNode.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuildDir", &fBuildDir);
      R__insp.InspectMember(fBuildDir, "fBuildDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlagsDebug", &fFlagsDebug);
      R__insp.InspectMember(fFlagsDebug, "fFlagsDebug.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlagsOpt", &fFlagsOpt);
      R__insp.InspectMember(fFlagsOpt, "fFlagsOpt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fListPaths", &fListPaths);
      R__insp.InspectMember(fListPaths, "fListPaths.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIncludePath", &fIncludePath);
      R__insp.InspectMember(fIncludePath, "fIncludePath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLinkedLibs", &fLinkedLibs);
      R__insp.InspectMember(fLinkedLibs, "fLinkedLibs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSoExt", &fSoExt);
      R__insp.InspectMember(fSoExt, "fSoExt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fObjExt", &fObjExt);
      R__insp.InspectMember(fObjExt, "fObjExt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAclicMode", &fAclicMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMakeSharedLib", &fMakeSharedLib);
      R__insp.InspectMember(fMakeSharedLib, "fMakeSharedLib.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMakeExe", &fMakeExe);
      R__insp.InspectMember(fMakeExe, "fMakeExe.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLinkdefSuffix", &fLinkdefSuffix);
      R__insp.InspectMember(fLinkdefSuffix, "fLinkdefSuffix.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAclicProperties", &fAclicProperties);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompiled", &fCompiled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHelpers", &fHelpers);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSystem(void *p) {
      return  p ? new(p) ::TSystem : new ::TSystem;
   }
   static void *newArray_TSystem(Long_t nElements, void *p) {
      return p ? new(p) ::TSystem[nElements] : new ::TSystem[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSystem(void *p) {
      delete ((::TSystem*)p);
   }
   static void deleteArray_TSystem(void *p) {
      delete [] ((::TSystem*)p);
   }
   static void destruct_TSystem(void *p) {
      typedef ::TSystem current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSystem

//______________________________________________________________________________
void TSystemFile::Streamer(TBuffer &R__b)
{
   // Stream an object of class TSystemFile.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TSystemFile::Class(),this);
   } else {
      R__b.WriteClassBuffer(TSystemFile::Class(),this);
   }
}

//______________________________________________________________________________
void TSystemFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSystemFile.
      TClass *R__cl = ::TSystemFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIconName", &fIconName);
      R__insp.InspectMember(fIconName, "fIconName.");
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSystemFile(void *p) {
      return  p ? new(p) ::TSystemFile : new ::TSystemFile;
   }
   static void *newArray_TSystemFile(Long_t nElements, void *p) {
      return p ? new(p) ::TSystemFile[nElements] : new ::TSystemFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSystemFile(void *p) {
      delete ((::TSystemFile*)p);
   }
   static void deleteArray_TSystemFile(void *p) {
      delete [] ((::TSystemFile*)p);
   }
   static void destruct_TSystemFile(void *p) {
      typedef ::TSystemFile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSystemFile

//______________________________________________________________________________
void TSystemDirectory::Streamer(TBuffer &R__b)
{
   // Stream an object of class TSystemDirectory.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TSystemDirectory::Class(),this);
   } else {
      R__b.WriteClassBuffer(TSystemDirectory::Class(),this);
   }
}

//______________________________________________________________________________
void TSystemDirectory::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSystemDirectory.
      TClass *R__cl = ::TSystemDirectory::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirsInBrowser", &fDirsInBrowser);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFilesInBrowser", &fFilesInBrowser);
      TSystemFile::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSystemDirectory(void *p) {
      return  p ? new(p) ::TSystemDirectory : new ::TSystemDirectory;
   }
   static void *newArray_TSystemDirectory(Long_t nElements, void *p) {
      return p ? new(p) ::TSystemDirectory[nElements] : new ::TSystemDirectory[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSystemDirectory(void *p) {
      delete ((::TSystemDirectory*)p);
   }
   static void deleteArray_TSystemDirectory(void *p) {
      delete [] ((::TSystemDirectory*)p);
   }
   static void destruct_TSystemDirectory(void *p) {
      typedef ::TSystemDirectory current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSystemDirectory

//______________________________________________________________________________
void TTask::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTask.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TTask::Class(),this);
   } else {
      R__b.WriteClassBuffer(TTask::Class(),this);
   }
}

//______________________________________________________________________________
void TTask::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTask.
      TClass *R__cl = ::TTask::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTasks", &fTasks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBreakin", &fBreakin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBreakout", &fBreakout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasExecuted", &fHasExecuted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTask(void *p) {
      return  p ? new(p) ::TTask : new ::TTask;
   }
   static void *newArray_TTask(Long_t nElements, void *p) {
      return p ? new(p) ::TTask[nElements] : new ::TTask[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTask(void *p) {
      delete ((::TTask*)p);
   }
   static void deleteArray_TTask(void *p) {
      delete [] ((::TTask*)p);
   }
   static void destruct_TTask(void *p) {
      typedef ::TTask current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTask

//______________________________________________________________________________
void TTime::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTime.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      R__b >> fMilliSec;
      R__b.CheckByteCount(R__s, R__c, TTime::IsA());
   } else {
      R__c = R__b.WriteVersion(TTime::IsA(), kTRUE);
      R__b << fMilliSec;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TTime::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTime.
      TClass *R__cl = ::TTime::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMilliSec", &fMilliSec);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTime(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTime : new ::TTime;
   }
   static void *newArray_TTime(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TTime[nElements] : new ::TTime[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTime(void *p) {
      delete ((::TTime*)p);
   }
   static void deleteArray_TTime(void *p) {
      delete [] ((::TTime*)p);
   }
   static void destruct_TTime(void *p) {
      typedef ::TTime current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTime(TBuffer &buf, void *obj) {
      ((::TTime*)obj)->::TTime::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTime

//______________________________________________________________________________
void TTimer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTimer.

   TSysEvtHandler::Streamer(R__b);
}

//______________________________________________________________________________
void TTimer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTimer.
      TClass *R__cl = ::TTimer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &fTime);
      R__insp.InspectMember(fTime, "fTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbsTime", &fAbsTime);
      R__insp.InspectMember(fAbsTime, "fAbsTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeout", &fTimeout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSync", &fSync);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntSyscalls", &fIntSyscalls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeID", &fTimeID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCommand", &fCommand);
      R__insp.InspectMember(fCommand, "fCommand.");
      TSysEvtHandler::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTimer(void *p) {
      return  p ? new(p) ::TTimer : new ::TTimer;
   }
   static void *newArray_TTimer(Long_t nElements, void *p) {
      return p ? new(p) ::TTimer[nElements] : new ::TTimer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTimer(void *p) {
      delete ((::TTimer*)p);
   }
   static void deleteArray_TTimer(void *p) {
      delete [] ((::TTimer*)p);
   }
   static void destruct_TTimer(void *p) {
      typedef ::TTimer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTimer(TBuffer &buf, void *obj) {
      ((::TTimer*)obj)->::TTimer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTimer

//______________________________________________________________________________
void TQObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQObject.
      TClass *R__cl = ::TQObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListOfSignals", &fListOfSignals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListOfConnections", &fListOfConnections);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalsBlocked", &fSignalsBlocked);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TQObject(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TQObject : new ::TQObject;
   }
   static void *newArray_TQObject(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TQObject[nElements] : new ::TQObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TQObject(void *p) {
      delete ((::TQObject*)p);
   }
   static void deleteArray_TQObject(void *p) {
      delete [] ((::TQObject*)p);
   }
   static void destruct_TQObject(void *p) {
      typedef ::TQObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TQObject(TBuffer &buf, void *obj) {
      ((::TQObject*)obj)->::TQObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TQObject

//______________________________________________________________________________
void TQObjSender::Streamer(TBuffer &R__b)
{
   // Stream an object of class TQObjSender.

   TQObject::Streamer(R__b);
}

//______________________________________________________________________________
void TQObjSender::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQObjSender.
      TClass *R__cl = ::TQObjSender::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSender", &fSender);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSenderClass", &fSenderClass);
      R__insp.InspectMember(fSenderClass, "fSenderClass.");
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TQObjSender(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TQObjSender : new ::TQObjSender;
   }
   static void *newArray_TQObjSender(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TQObjSender[nElements] : new ::TQObjSender[nElements];
   }
   // Wrapper around operator delete
   static void delete_TQObjSender(void *p) {
      delete ((::TQObjSender*)p);
   }
   static void deleteArray_TQObjSender(void *p) {
      delete [] ((::TQObjSender*)p);
   }
   static void destruct_TQObjSender(void *p) {
      typedef ::TQObjSender current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TQObjSender(TBuffer &buf, void *obj) {
      ((::TQObjSender*)obj)->::TQObjSender::Streamer(buf);
   }
} // end of namespace ROOT for class ::TQObjSender

//______________________________________________________________________________
void TQClass::Streamer(TBuffer &R__b)
{
   // Stream an object of class TQClass.

   TQObject::Streamer(R__b);
   TClass::Streamer(R__b);
}

//______________________________________________________________________________
void TQClass::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQClass.
      TClass *R__cl = ::TQClass::IsA();
      if (R__cl || R__insp.IsA()) { }
      TQObject::ShowMembers(R__insp);
      TClass::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TQClass(void *p) {
      delete ((::TQClass*)p);
   }
   static void deleteArray_TQClass(void *p) {
      delete [] ((::TQClass*)p);
   }
   static void destruct_TQClass(void *p) {
      typedef ::TQClass current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TQClass(TBuffer &buf, void *obj) {
      ((::TQClass*)obj)->::TQClass::Streamer(buf);
   }
} // end of namespace ROOT for class ::TQClass

//______________________________________________________________________________
void TQConnection::Streamer(TBuffer &R__b)
{
   // Stream an object of class TQConnection.

   TList::Streamer(R__b);
   TQObject::Streamer(R__b);
}

//______________________________________________________________________________
void TQConnection::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQConnection.
      TClass *R__cl = ::TQConnection::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlot", &fSlot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReceiver", &fReceiver);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      TList::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TQConnection(void *p) {
      return  p ? new(p) ::TQConnection : new ::TQConnection;
   }
   static void *newArray_TQConnection(Long_t nElements, void *p) {
      return p ? new(p) ::TQConnection[nElements] : new ::TQConnection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TQConnection(void *p) {
      delete ((::TQConnection*)p);
   }
   static void deleteArray_TQConnection(void *p) {
      delete [] ((::TQConnection*)p);
   }
   static void destruct_TQConnection(void *p) {
      typedef ::TQConnection current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TQConnection(TBuffer &buf, void *obj) {
      ((::TQConnection*)obj)->::TQConnection::Streamer(buf);
   }
} // end of namespace ROOT for class ::TQConnection

//______________________________________________________________________________
void TQCommand::Streamer(TBuffer &R__b)
{
   // Stream an object of class TQCommand.

   TList::Streamer(R__b);
   TQObject::Streamer(R__b);
}

//______________________________________________________________________________
void TQCommand::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQCommand.
      TClass *R__cl = ::TQCommand::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRedo", &fRedo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRedoArgs", &fRedoArgs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndoArgs", &fUndoArgs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNRargs", &fNRargs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNUargs", &fNUargs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewDelete", &fNewDelete);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
      R__insp.InspectMember(fTitle, "fTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      TList::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TQCommand(void *p) {
      return  p ? new(p) ::TQCommand : new ::TQCommand;
   }
   static void *newArray_TQCommand(Long_t nElements, void *p) {
      return p ? new(p) ::TQCommand[nElements] : new ::TQCommand[nElements];
   }
   // Wrapper around operator delete
   static void delete_TQCommand(void *p) {
      delete ((::TQCommand*)p);
   }
   static void deleteArray_TQCommand(void *p) {
      delete [] ((::TQCommand*)p);
   }
   static void destruct_TQCommand(void *p) {
      typedef ::TQCommand current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TQCommand(TBuffer &buf, void *obj) {
      ((::TQCommand*)obj)->::TQCommand::Streamer(buf);
   }
} // end of namespace ROOT for class ::TQCommand

//______________________________________________________________________________
void TQUndoManager::Streamer(TBuffer &R__b)
{
   // Stream an object of class TQUndoManager.

   TQCommand::Streamer(R__b);
}

//______________________________________________________________________________
void TQUndoManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQUndoManager.
      TClass *R__cl = ::TQUndoManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimit", &fLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogBook", &fLogBook);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogging", &fLogging);
      TQCommand::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TQUndoManager(void *p) {
      return  p ? new(p) ::TQUndoManager : new ::TQUndoManager;
   }
   static void *newArray_TQUndoManager(Long_t nElements, void *p) {
      return p ? new(p) ::TQUndoManager[nElements] : new ::TQUndoManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TQUndoManager(void *p) {
      delete ((::TQUndoManager*)p);
   }
   static void deleteArray_TQUndoManager(void *p) {
      delete [] ((::TQUndoManager*)p);
   }
   static void destruct_TQUndoManager(void *p) {
      typedef ::TQUndoManager current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TQUndoManager(TBuffer &buf, void *obj) {
      ((::TQUndoManager*)obj)->::TQUndoManager::Streamer(buf);
   }
} // end of namespace ROOT for class ::TQUndoManager

//______________________________________________________________________________
void TUUID::Streamer(TBuffer &R__b)
{
   // Stream an object of class TUUID.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TUUID::Class(),this);
   } else {
      R__b.WriteClassBuffer(TUUID::Class(),this);
   }
}

//______________________________________________________________________________
void TUUID::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TUUID.
      TClass *R__cl = ::TUUID::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUUIDIndex", &fUUIDIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeLow", &fTimeLow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeMid", &fTimeMid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeHiAndVersion", &fTimeHiAndVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClockSeqHiAndReserved", &fClockSeqHiAndReserved);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClockSeqLow", &fClockSeqLow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNode[6]", fNode);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TUUID(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TUUID : new ::TUUID;
   }
   static void *newArray_TUUID(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TUUID[nElements] : new ::TUUID[nElements];
   }
   // Wrapper around operator delete
   static void delete_TUUID(void *p) {
      delete ((::TUUID*)p);
   }
   static void deleteArray_TUUID(void *p) {
      delete [] ((::TUUID*)p);
   }
   static void destruct_TUUID(void *p) {
      typedef ::TUUID current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TUUID

//______________________________________________________________________________
void TPluginHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TPluginHandler.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      fBase.Streamer(R__b);
      fRegexp.Streamer(R__b);
      fClass.Streamer(R__b);
      fPlugin.Streamer(R__b);
      fCtor.Streamer(R__b);
      fOrigin.Streamer(R__b);
      R__b >> fIsMacro;
      R__b >> fIsGlobal;
      R__b.CheckByteCount(R__s, R__c, TPluginHandler::IsA());
   } else {
      R__c = R__b.WriteVersion(TPluginHandler::IsA(), kTRUE);
      TObject::Streamer(R__b);
      fBase.Streamer(R__b);
      fRegexp.Streamer(R__b);
      fClass.Streamer(R__b);
      fPlugin.Streamer(R__b);
      fCtor.Streamer(R__b);
      fOrigin.Streamer(R__b);
      R__b << fIsMacro;
      R__b << fIsGlobal;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TPluginHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPluginHandler.
      TClass *R__cl = ::TPluginHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBase", &fBase);
      R__insp.InspectMember(fBase, "fBase.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRegexp", &fRegexp);
      R__insp.InspectMember(fRegexp, "fRegexp.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", &fClass);
      R__insp.InspectMember(fClass, "fClass.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlugin", &fPlugin);
      R__insp.InspectMember(fPlugin, "fPlugin.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCtor", &fCtor);
      R__insp.InspectMember(fCtor, "fCtor.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrigin", &fOrigin);
      R__insp.InspectMember(fOrigin, "fOrigin.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCallEnv", &fCallEnv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanCall", &fCanCall);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMacro", &fIsMacro);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsGlobal", &fIsGlobal);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around a custom streamer member function.
   static void streamer_TPluginHandler(TBuffer &buf, void *obj) {
      ((::TPluginHandler*)obj)->::TPluginHandler::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPluginHandler

//______________________________________________________________________________
void TPluginManager::Streamer(TBuffer &R__b)
{
   // Stream an object of class TPluginManager.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> fHandlers;
      R__b.CheckByteCount(R__s, R__c, TPluginManager::IsA());
   } else {
      R__c = R__b.WriteVersion(TPluginManager::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << fHandlers;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TPluginManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPluginManager.
      TClass *R__cl = ::TPluginManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHandlers", &fHandlers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasesLoaded", &fBasesLoaded);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadingDirs", &fReadingDirs);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPluginManager(void *p) {
      return  p ? new(p) ::TPluginManager : new ::TPluginManager;
   }
   static void *newArray_TPluginManager(Long_t nElements, void *p) {
      return p ? new(p) ::TPluginManager[nElements] : new ::TPluginManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPluginManager(void *p) {
      delete ((::TPluginManager*)p);
   }
   static void deleteArray_TPluginManager(void *p) {
      delete [] ((::TPluginManager*)p);
   }
   static void destruct_TPluginManager(void *p) {
      typedef ::TPluginManager current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPluginManager(TBuffer &buf, void *obj) {
      ((::TPluginManager*)obj)->::TPluginManager::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPluginManager

namespace ROOT {
   // Wrappers around operator new
   static void *new_stringcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::string::iterator : new ::string::iterator;
   }
   static void *newArray_stringcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::string::iterator[nElements] : new ::string::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_stringcLcLiterator(void *p) {
      delete ((::string::iterator*)p);
   }
   static void deleteArray_stringcLcLiterator(void *p) {
      delete [] ((::string::iterator*)p);
   }
   static void destruct_stringcLcLiterator(void *p) {
      typedef ::string::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::string::iterator

namespace ROOT {
   // Wrappers around operator new
   static void *new_FileStat_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::FileStat_t : new ::FileStat_t;
   }
   static void *newArray_FileStat_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::FileStat_t[nElements] : new ::FileStat_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_FileStat_t(void *p) {
      delete ((::FileStat_t*)p);
   }
   static void deleteArray_FileStat_t(void *p) {
      delete [] ((::FileStat_t*)p);
   }
   static void destruct_FileStat_t(void *p) {
      typedef ::FileStat_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::FileStat_t

namespace ROOT {
   // Wrappers around operator new
   static void *new_UserGroup_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::UserGroup_t : new ::UserGroup_t;
   }
   static void *newArray_UserGroup_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::UserGroup_t[nElements] : new ::UserGroup_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_UserGroup_t(void *p) {
      delete ((::UserGroup_t*)p);
   }
   static void deleteArray_UserGroup_t(void *p) {
      delete [] ((::UserGroup_t*)p);
   }
   static void destruct_UserGroup_t(void *p) {
      typedef ::UserGroup_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::UserGroup_t

//______________________________________________________________________________
void SysInfo_t::Streamer(TBuffer &R__b)
{
   // Stream an object of class SysInfo_t.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      fOS.Streamer(R__b);
      fModel.Streamer(R__b);
      fCpuType.Streamer(R__b);
      R__b >> fCpus;
      R__b >> fCpuSpeed;
      R__b >> fBusSpeed;
      R__b >> fL2Cache;
      R__b >> fPhysRam;
      R__b.CheckByteCount(R__s, R__c, SysInfo_t::IsA());
   } else {
      R__c = R__b.WriteVersion(SysInfo_t::IsA(), kTRUE);
      fOS.Streamer(R__b);
      fModel.Streamer(R__b);
      fCpuType.Streamer(R__b);
      R__b << fCpus;
      R__b << fCpuSpeed;
      R__b << fBusSpeed;
      R__b << fL2Cache;
      R__b << fPhysRam;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void SysInfo_t::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class SysInfo_t.
      TClass *R__cl = ::SysInfo_t::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOS", &fOS);
      R__insp.InspectMember(fOS, "fOS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModel", &fModel);
      R__insp.InspectMember(fModel, "fModel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuType", &fCpuType);
      R__insp.InspectMember(fCpuType, "fCpuType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpus", &fCpus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuSpeed", &fCpuSpeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBusSpeed", &fBusSpeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fL2Cache", &fL2Cache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhysRam", &fPhysRam);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_SysInfo_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::SysInfo_t : new ::SysInfo_t;
   }
   static void *newArray_SysInfo_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::SysInfo_t[nElements] : new ::SysInfo_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_SysInfo_t(void *p) {
      delete ((::SysInfo_t*)p);
   }
   static void deleteArray_SysInfo_t(void *p) {
      delete [] ((::SysInfo_t*)p);
   }
   static void destruct_SysInfo_t(void *p) {
      typedef ::SysInfo_t current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_SysInfo_t(TBuffer &buf, void *obj) {
      ((::SysInfo_t*)obj)->::SysInfo_t::Streamer(buf);
   }
} // end of namespace ROOT for class ::SysInfo_t

//______________________________________________________________________________
void CpuInfo_t::Streamer(TBuffer &R__b)
{
   // Stream an object of class CpuInfo_t.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      R__b >> fLoad1m;
      R__b >> fLoad5m;
      R__b >> fLoad15m;
      R__b >> fUser;
      R__b >> fSys;
      R__b >> fTotal;
      R__b >> fIdle;
      R__b.CheckByteCount(R__s, R__c, CpuInfo_t::IsA());
   } else {
      R__c = R__b.WriteVersion(CpuInfo_t::IsA(), kTRUE);
      R__b << fLoad1m;
      R__b << fLoad5m;
      R__b << fLoad15m;
      R__b << fUser;
      R__b << fSys;
      R__b << fTotal;
      R__b << fIdle;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void CpuInfo_t::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class CpuInfo_t.
      TClass *R__cl = ::CpuInfo_t::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLoad1m", &fLoad1m);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLoad5m", &fLoad5m);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLoad15m", &fLoad15m);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSys", &fSys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotal", &fTotal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdle", &fIdle);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_CpuInfo_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::CpuInfo_t : new ::CpuInfo_t;
   }
   static void *newArray_CpuInfo_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::CpuInfo_t[nElements] : new ::CpuInfo_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_CpuInfo_t(void *p) {
      delete ((::CpuInfo_t*)p);
   }
   static void deleteArray_CpuInfo_t(void *p) {
      delete [] ((::CpuInfo_t*)p);
   }
   static void destruct_CpuInfo_t(void *p) {
      typedef ::CpuInfo_t current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_CpuInfo_t(TBuffer &buf, void *obj) {
      ((::CpuInfo_t*)obj)->::CpuInfo_t::Streamer(buf);
   }
} // end of namespace ROOT for class ::CpuInfo_t

//______________________________________________________________________________
void MemInfo_t::Streamer(TBuffer &R__b)
{
   // Stream an object of class MemInfo_t.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      R__b >> fMemTotal;
      R__b >> fMemUsed;
      R__b >> fMemFree;
      R__b >> fSwapTotal;
      R__b >> fSwapUsed;
      R__b >> fSwapFree;
      R__b.CheckByteCount(R__s, R__c, MemInfo_t::IsA());
   } else {
      R__c = R__b.WriteVersion(MemInfo_t::IsA(), kTRUE);
      R__b << fMemTotal;
      R__b << fMemUsed;
      R__b << fMemFree;
      R__b << fSwapTotal;
      R__b << fSwapUsed;
      R__b << fSwapFree;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void MemInfo_t::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class MemInfo_t.
      TClass *R__cl = ::MemInfo_t::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemTotal", &fMemTotal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemUsed", &fMemUsed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemFree", &fMemFree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSwapTotal", &fSwapTotal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSwapUsed", &fSwapUsed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSwapFree", &fSwapFree);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_MemInfo_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MemInfo_t : new ::MemInfo_t;
   }
   static void *newArray_MemInfo_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MemInfo_t[nElements] : new ::MemInfo_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_MemInfo_t(void *p) {
      delete ((::MemInfo_t*)p);
   }
   static void deleteArray_MemInfo_t(void *p) {
      delete [] ((::MemInfo_t*)p);
   }
   static void destruct_MemInfo_t(void *p) {
      typedef ::MemInfo_t current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_MemInfo_t(TBuffer &buf, void *obj) {
      ((::MemInfo_t*)obj)->::MemInfo_t::Streamer(buf);
   }
} // end of namespace ROOT for class ::MemInfo_t

//______________________________________________________________________________
void ProcInfo_t::Streamer(TBuffer &R__b)
{
   // Stream an object of class ProcInfo_t.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      R__b >> fCpuUser;
      R__b >> fCpuSys;
      R__b >> fMemResident;
      R__b >> fMemVirtual;
      R__b.CheckByteCount(R__s, R__c, ProcInfo_t::IsA());
   } else {
      R__c = R__b.WriteVersion(ProcInfo_t::IsA(), kTRUE);
      R__b << fCpuUser;
      R__b << fCpuSys;
      R__b << fMemResident;
      R__b << fMemVirtual;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void ProcInfo_t::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class ProcInfo_t.
      TClass *R__cl = ::ProcInfo_t::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuUser", &fCpuUser);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuSys", &fCpuSys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemResident", &fMemResident);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMemVirtual", &fMemVirtual);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_ProcInfo_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ProcInfo_t : new ::ProcInfo_t;
   }
   static void *newArray_ProcInfo_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ProcInfo_t[nElements] : new ::ProcInfo_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_ProcInfo_t(void *p) {
      delete ((::ProcInfo_t*)p);
   }
   static void deleteArray_ProcInfo_t(void *p) {
      delete [] ((::ProcInfo_t*)p);
   }
   static void destruct_ProcInfo_t(void *p) {
      typedef ::ProcInfo_t current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ProcInfo_t(TBuffer &buf, void *obj) {
      ((::ProcInfo_t*)obj)->::ProcInfo_t::Streamer(buf);
   }
} // end of namespace ROOT for class ::ProcInfo_t

namespace ROOT {
   // Wrappers around operator new
   static void *new_RedirectHandle_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RedirectHandle_t : new ::RedirectHandle_t;
   }
   static void *newArray_RedirectHandle_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RedirectHandle_t[nElements] : new ::RedirectHandle_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_RedirectHandle_t(void *p) {
      delete ((::RedirectHandle_t*)p);
   }
   static void deleteArray_RedirectHandle_t(void *p) {
      delete [] ((::RedirectHandle_t*)p);
   }
   static void destruct_RedirectHandle_t(void *p) {
      typedef ::RedirectHandle_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RedirectHandle_t

namespace ROOT {
   void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETStringgR_Dictionary();
   static void *new_vectorlETStringgR(void *p = 0);
   static void *newArray_vectorlETStringgR(Long_t size, void *p);
   static void delete_vectorlETStringgR(void *p);
   static void deleteArray_vectorlETStringgR(void *p);
   static void destruct_vectorlETStringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
   {
      vector<TString> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TString>", -2, "prec_stl/vector", 49,
                  typeid(vector<TString>), DefineBehavior(ptr, ptr),
                  0, &vectorlETStringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TString>) );
      instance.SetNew(&new_vectorlETStringgR);
      instance.SetNewArray(&newArray_vectorlETStringgR);
      instance.SetDelete(&delete_vectorlETStringgR);
      instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
      instance.SetDestructor(&destruct_vectorlETStringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETStringgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETStringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
   }
   static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETStringgR(void *p) {
      delete ((vector<TString>*)p);
   }
   static void deleteArray_vectorlETStringgR(void *p) {
      delete [] ((vector<TString>*)p);
   }
   static void destruct_vectorlETStringgR(void *p) {
      typedef vector<TString> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TString>

namespace ROOT {
   void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEstringgR_Dictionary();
   static void *new_vectorlEstringgR(void *p = 0);
   static void *newArray_vectorlEstringgR(Long_t size, void *p);
   static void delete_vectorlEstringgR(void *p);
   static void deleteArray_vectorlEstringgR(void *p);
   static void destruct_vectorlEstringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
   {
      vector<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "prec_stl/vector", 49,
                  typeid(vector<string>), DefineBehavior(ptr, ptr),
                  0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEstringgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete ((vector<string>*)p);
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] ((vector<string>*)p);
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<string>

/********************************************************
* core/base/src/G__Base2.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.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableG__Base2();

extern "C" void G__set_cpp_environmentG__Base2() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TApplication.h");
  G__add_compiledheader("TApplicationImp.h");
  G__add_compiledheader("TAtt3D.h");
  G__add_compiledheader("TAttAxis.h");
  G__add_compiledheader("TAttBBox.h");
  G__add_compiledheader("TAttFill.h");
  G__add_compiledheader("TAttLine.h");
  G__add_compiledheader("TAttMarker.h");
  G__add_compiledheader("TAttPad.h");
  G__add_compiledheader("TAttText.h");
  G__add_compiledheader("TBenchmark.h");
  G__add_compiledheader("TBrowser.h");
  G__add_compiledheader("TBrowserImp.h");
  G__add_compiledheader("TBuffer3D.h");
  G__add_compiledheader("TBuffer3DTypes.h");
  G__add_compiledheader("TBuffer.h");
  G__add_compiledheader("TCanvasImp.h");
  G__add_compiledheader("TColor.h");
  G__add_compiledheader("TContextMenu.h");
  G__add_compiledheader("TContextMenuImp.h");
  G__add_compiledheader("TControlBarImp.h");
  G__add_compiledheader("TDatime.h");
  G__add_compiledheader("TDirectory.h");
  G__add_compiledheader("TEnv.h");
  G__add_compiledheader("TError.h");
  G__add_compiledheader("TException.h");
  G__add_compiledheader("TExec.h");
  G__add_compiledheader("TFolder.h");
  G__add_compiledheader("TGuiFactory.h");
  G__add_compiledheader("TInspectorImp.h");
  G__add_compiledheader("TMacro.h");
  G__add_compiledheader("TMathBase.h");
  G__add_compiledheader("TMD5.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMessageHandler.h");
  G__add_compiledheader("TNamed.h");
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TObjString.h");
  G__add_compiledheader("TPluginManager.h");
  G__add_compiledheader("TPoint.h");
  G__add_compiledheader("TPRegexp.h");
  G__add_compiledheader("TProcessID.h");
  G__add_compiledheader("TProcessUUID.h");
  G__add_compiledheader("TQClass.h");
  G__add_compiledheader("TQCommand.h");
  G__add_compiledheader("TQConnection.h");
  G__add_compiledheader("TQObject.h");
  G__add_compiledheader("TRefCnt.h");
  G__add_compiledheader("TRef.h");
  G__add_compiledheader("TRegexp.h");
  G__add_compiledheader("TRemoteObject.h");
  G__add_compiledheader("TROOT.h");
  G__add_compiledheader("TRootIOCtor.h");
  G__add_compiledheader("TStopwatch.h");
  G__add_compiledheader("TStorage.h");
  G__add_compiledheader("TString.h");
  G__add_compiledheader("TStringLong.h");
  G__add_compiledheader("TStyle.h");
  G__add_compiledheader("TSysEvtHandler.h");
  G__add_compiledheader("TSystemDirectory.h");
  G__add_compiledheader("TSystemFile.h");
  G__add_compiledheader("TSystem.h");
  G__add_compiledheader("TTask.h");
  G__add_compiledheader("TTime.h");
  G__add_compiledheader("TTimer.h");
  G__add_compiledheader("TUUID.h");
  G__add_compiledheader("TVersionCheck.h");
  G__add_compiledheader("TVirtualFFT.h");
  G__add_compiledheader("TVirtualGL.h");
  G__add_compiledheader("TVirtualPadEditor.h");
  G__add_compiledheader("TVirtualPad.h");
  G__add_compiledheader("TVirtualPadPainter.h");
  G__add_compiledheader("TVirtualPS.h");
  G__add_compiledheader("TVirtualViewer3D.h");
  G__cpp_reset_tagtableG__Base2();
}
#include <new>
extern "C" int G__cpp_dllrevG__Base2() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* TMemberInspector */
static int G__G__Base2_9_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->Inspect((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMemberInspector*) G__getstructoffset())->GetParent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMemberInspector*) G__getstructoffset())->GetParentLen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->AddToParent((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->RemoveFromParent((Ssiz_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->InspectMember(*(TObject*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->InspectMember((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->InspectMember((TClass*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->GenericShowMembers((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMemberInspector::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMemberInspector::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMemberInspector::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMemberInspector::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMemberInspector*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMemberInspector*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMemberInspector::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMemberInspector::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMemberInspector::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_9_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMemberInspector::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMemberInspector G__TTMemberInspector;
static int G__G__Base2_9_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TMemberInspector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMemberInspector*) (soff+(sizeof(TMemberInspector)*i)))->~G__TTMemberInspector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMemberInspector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMemberInspector*) (soff))->~G__TTMemberInspector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_9_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMemberInspector* dest = (TMemberInspector*) G__getstructoffset();
   *dest = *(TMemberInspector*) libp->para[0].ref;
   const TMemberInspector& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TObject */
static int G__G__Base2_10_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TObject[n];
     } else {
       p = new((void*) gvp) TObject[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TObject;
     } else {
       p = new((void*) gvp) TObject;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TObject(*(TObject*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TObject(*(TObject*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TObject& obj = ((TObject*) G__getstructoffset())->operator=(*(TObject*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TObject*) G__getstructoffset())->AppendPad((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TObject*) G__getstructoffset())->AppendPad();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->Browse((TBrowser*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->ClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TObject*) G__getstructoffset())->Clear((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TObject*) G__getstructoffset())->Clear();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->Clone((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->Clone());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TObject*) G__getstructoffset())->Compare((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObject*) G__getstructoffset())->Copy(*(TObject*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TObject*) G__getstructoffset())->Delete((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TObject*) G__getstructoffset())->Delete();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TObject*) G__getstructoffset())->DistancetoPrimitive((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TObject*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TObject*) G__getstructoffset())->Draw();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObject*) G__getstructoffset())->DrawClass();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->DrawClone());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObject*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TObject*) G__getstructoffset())->Execute((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TObject*) G__getstructoffset())->Execute((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TObject*) G__getstructoffset())->Execute((TMethod*) G__int(libp->para[0]), (TObjArray*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TObject*) G__getstructoffset())->Execute((TMethod*) G__int(libp->para[0]), (TObjArray*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->ExecuteEvent((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->FindObject((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->FindObject((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->GetDrawOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TObject*) G__getstructoffset())->GetUniqueID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->GetIconName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->GetObjectInfo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TObject*) G__getstructoffset())->GetTitle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TObject*) G__getstructoffset())->HandleTimer((TTimer*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TObject*) G__getstructoffset())->Hash());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->InheritsFrom((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->InheritsFrom((TClass*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObject*) G__getstructoffset())->Inspect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->IsFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->IsEqual((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->IsSortable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->IsOnHeap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->IsZombie());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TObject*) G__getstructoffset())->Notify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TObject*) G__getstructoffset())->ls((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TObject*) G__getstructoffset())->ls();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TObject*) G__getstructoffset())->Paint((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TObject*) G__getstructoffset())->Paint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->Pop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TObject*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TObject*) G__getstructoffset())->Print();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TObject*) G__getstructoffset())->Read((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->RecursiveRemove((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TObject*) G__getstructoffset())->SaveAs((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TObject*) G__getstructoffset())->SaveAs((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TObject*) G__getstructoffset())->SaveAs();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TObject*) G__getstructoffset())->SavePrimitive(*(ostream*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TObject*) G__getstructoffset())->SavePrimitive(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TObject*) G__getstructoffset())->SetDrawOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TObject*) G__getstructoffset())->SetDrawOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->SetUniqueID((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->UseCurrentStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TObject*) G__getstructoffset())->Write((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TObject*) G__getstructoffset())->Write((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TObject*) G__getstructoffset())->Write((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TObject*) G__getstructoffset())->Write());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TObject*) G__getstructoffset())->Write((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TObject*) G__getstructoffset())->Write((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TObject*) G__getstructoffset())->Write((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TObject*) G__getstructoffset())->Write());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TObject*) G__getstructoffset())->operator new((size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TObject*) G__getstructoffset())->operator new[]((size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TObject*) G__getstructoffset())->operator new((size_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TObject*) G__getstructoffset())->operator new[]((size_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::operator delete((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::operator delete[]((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::operator delete((void*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::operator delete[]((void*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->SetBit((UInt_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->SetBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->ResetBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TObject*) G__getstructoffset())->TestBit((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TObject*) G__getstructoffset())->TestBits((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->InvertBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      ((const TObject*) G__getstructoffset())->Info((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      ((const TObject*) G__getstructoffset())->Warning((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      ((const TObject*) G__getstructoffset())->Error((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      ((const TObject*) G__getstructoffset())->SysError((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      ((const TObject*) G__getstructoffset())->Fatal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObject*) G__getstructoffset())->AbstractMethod((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObject*) G__getstructoffset())->MayNotUse((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) TObject::GetDtorOnly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::SetDtorOnly((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TObject::GetObjectStat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::SetObjectStat((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TObject*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_10_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TObject G__TTObject;
static int G__G__Base2_10_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 1
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TObject*) (soff+(sizeof(TObject)*i)))->~G__TTObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TObject*) (soff))->~G__TTObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TNamed */
static int G__G__Base2_11_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNamed* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNamed[n];
     } else {
       p = new((void*) gvp) TNamed[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNamed;
     } else {
       p = new((void*) gvp) TNamed;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TNamed));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNamed* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TNamed((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TNamed((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TNamed));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNamed* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TNamed(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TNamed(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TNamed));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNamed* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TNamed(*(TNamed*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TNamed(*(TNamed*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TNamed));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TNamed& obj = ((TNamed*) G__getstructoffset())->operator=(*(TNamed*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TNamed*) G__getstructoffset())->FillBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TNamed*) G__getstructoffset())->SetName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TNamed*) G__getstructoffset())->SetNameTitle((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TNamed*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TNamed*) G__getstructoffset())->SetTitle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TNamed*) G__getstructoffset())->Sizeof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TNamed::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNamed::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TNamed::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TNamed::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TNamed*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNamed::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TNamed::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNamed::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_11_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TNamed::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TNamed G__TTNamed;
static int G__G__Base2_11_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TNamed*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TNamed*) (soff+(sizeof(TNamed)*i)))->~G__TTNamed();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TNamed*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TNamed*) (soff))->~G__TTNamed();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TString */
static int G__G__Base2_13_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TString[n];
     } else {
       p = new((void*) gvp) TString[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TString;
     } else {
       p = new((void*) gvp) TString;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString((Ssiz_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TString((Ssiz_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TString(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TString((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TString((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString(*(string*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TString(*(string*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString((char) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TString((char) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString((char) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TString((char) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TString(*(TSubString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TString(*(TSubString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->FillBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->ReadBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Sizeof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TString::ReadString(*(TBuffer*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TString::WriteString(*(TBuffer*) libp->para[0].ref, (TString*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TString*) G__getstructoffset())->Gets((FILE*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TString*) G__getstructoffset())->Gets((FILE*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->Puts((FILE*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TString*) G__getstructoffset())->operator const char*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator=((char) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator=(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator=(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator=(*(TSubString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((char) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((Short_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((UShort_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((Long_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((ULong_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((Float_t) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((Double_t) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((Long64_t) G__Longlong(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->operator+=((ULong64_t) G__ULonglong(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((TString*) G__getstructoffset())->operator[]((Ssiz_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((TString*) G__getstructoffset())->operator()((Ssiz_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TString*) G__getstructoffset())->operator[]((Ssiz_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TString*) G__getstructoffset())->operator()((Ssiz_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->operator()((Ssiz_t) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         pobj = new TSubString(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__Base2_13_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->operator()(*(TRegexp*) libp->para[0].ref);
         pobj = new TSubString(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__Base2_13_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->operator()(*(TRegexp*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1]));
         pobj = new TSubString(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__Base2_13_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->operator()(*(TPRegexp*) libp->para[0].ref);
         pobj = new TSubString(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__Base2_13_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->operator()(*(TPRegexp*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1]));
         pobj = new TSubString(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__Base2_13_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->SubString((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, (TString::ECaseCompare) G__int(libp->para[2]));
         pobj = new TSubString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->SubString((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         pobj = new TSubString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->SubString((const char*) G__int(libp->para[0]));
         pobj = new TSubString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Append((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Append((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Append(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Append(*(TString*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TString& obj = ((TString*) G__getstructoffset())->Append((char) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TString& obj = ((TString*) G__getstructoffset())->Append((char) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Atoi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TString*) G__getstructoffset())->Atoll());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TString*) G__getstructoffset())->Atof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->BeginsWith((const char*) G__int(libp->para[0]), (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->BeginsWith((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->BeginsWith(*(TString*) libp->para[0].ref, (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->BeginsWith(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TString*) G__getstructoffset())->Capacity((Ssiz_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Chop();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->CompareTo((const char*) G__int(libp->para[0]), (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->CompareTo((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->CompareTo(*(TString*) libp->para[0].ref, (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->CompareTo(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Contains((const char*) G__int(libp->para[0]), (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Contains((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Contains(*(TString*) libp->para[0].ref, (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Contains(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Contains(*(TRegexp*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Contains(*(TPRegexp*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->CountChar((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TString*) G__getstructoffset())->Copy();
         pobj = new TString(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__Base2_13_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TString*) G__getstructoffset())->Data());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->EndsWith((const char*) G__int(libp->para[0]), (TString::ECaseCompare) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->EndsWith((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->First((char) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->First((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      ((TString*) G__getstructoffset())->Form((const char*) G__int(libp->para[0]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((const TString*) G__getstructoffset())->Hash((TString::ECaseCompare) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((const TString*) G__getstructoffset())->Hash());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, (TString::ECaseCompare) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TString*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1])
, (TString::ECaseCompare) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TString*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, (Ssiz_t) G__int(libp->para[2]), (TString::ECaseCompare) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TString*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1])
, (Ssiz_t) G__int(libp->para[2]), (TString::ECaseCompare) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TRegexp*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TRegexp*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TRegexp*) libp->para[0].ref, (Ssiz_t*) G__int(libp->para[1])
, (Ssiz_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TRegexp*) libp->para[0].ref, (Ssiz_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TPRegexp*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TPRegexp*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TPRegexp*) libp->para[0].ref, (Ssiz_t*) G__int(libp->para[1])
, (Ssiz_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Index(*(TPRegexp*) libp->para[0].ref, (Ssiz_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Insert((Ssiz_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Insert((Ssiz_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Ssiz_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Insert((Ssiz_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Insert((Ssiz_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Ssiz_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsAscii());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsAlpha());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsAlnum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsDigit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsFloat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsHex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsNull());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->IsWhitespace());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Last((char) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TString*) G__getstructoffset())->Length());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->MaybeRegexp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->MaybeWildcard());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Prepend((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Prepend((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Prepend(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Prepend(*(TString*) libp->para[0].ref, (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TString& obj = ((TString*) G__getstructoffset())->Prepend((char) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TString& obj = ((TString*) G__getstructoffset())->Prepend((char) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadFile(*(istream*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadLine(*(istream*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadLine(*(istream*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadString(*(istream*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadToDelim(*(istream*) libp->para[0].ref, (char) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadToDelim(*(istream*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = ((TString*) G__getstructoffset())->ReadToken(*(istream*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Remove((Ssiz_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Remove((Ssiz_t) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Remove((TString::EStripType) G__int(libp->para[0]), (char) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Replace((Ssiz_t) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Replace((Ssiz_t) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Ssiz_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Replace((Ssiz_t) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, *(TString*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->Replace((Ssiz_t) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, *(TString*) libp->para[2].ref, (Ssiz_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->ReplaceAll(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->ReplaceAll(*(TString*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->ReplaceAll((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->ReplaceAll((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TString*) G__getstructoffset())->ReplaceAll((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Ssiz_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->Resize((Ssiz_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->Strip((TString::EStripType) G__int(libp->para[0]), (char) G__int(libp->para[1]));
         pobj = new TSubString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->Strip((TString::EStripType) G__int(libp->para[0]));
         pobj = new TSubString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const TSubString* pobj;
         const TSubString xobj = ((const TString*) G__getstructoffset())->Strip();
         pobj = new TSubString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->ToLower();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->ToUpper();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TString*) G__getstructoffset())->Tokenize(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Tokenize(*(TString*) libp->para[0].ref, *(Ssiz_t*) G__Intref(&libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const TString*) G__getstructoffset())->Tokenize(*(TString*) libp->para[0].ref, *(Ssiz_t*) G__Intref(&libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TString::Hash((void*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) TString::InitialCapacity((Ssiz_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) TString::InitialCapacity());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) TString::MaxWaste((Ssiz_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) TString::MaxWaste());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) TString::ResizeIncrement((Ssiz_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) TString::ResizeIncrement());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TString::GetInitialCapacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TString::GetResizeIncrement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TString::GetMaxWaste());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      {
         TString* pobj;
         TString xobj = TString::Format((const char*) G__int(libp->para[0]), G__va_arg_bufobj);
         pobj = new TString(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__Base2_13_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TString::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TString::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TString::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TString::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TString*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TString*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TString::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TString::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TString::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_13_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TString::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TString G__TTString;
static int G__G__Base2_13_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TString*) (soff+(sizeof(TString)*i)))->~G__TTString();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TString*) (soff))->~G__TTString();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* string */
static int G__G__Base2_53_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new string[n];
     } else {
       p = new((void*) gvp) string[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new string;
     } else {
       p = new((void*) gvp) string;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_string));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new string(*(string*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) string(*(string*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_string));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new string(
*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) string(
*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_string));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new string((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) string((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_string));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new string((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) string((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_string));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new string((size_t) G__int(libp->para[0]), (char) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) string((size_t) G__int(libp->para[0]), (char) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_string));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->operator=(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->operator=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->operator=((char) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->operator+=(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->operator+=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->operator+=((char) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->append(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->append(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->append((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->append((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->append((size_t) G__int(libp->para[0]), (char) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->assign(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->assign(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->assign((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->assign((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->assign((size_t) G__int(libp->para[0]), (char) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->insert((size_t) G__int(libp->para[0]), *(string*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->insert((size_t) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (size_t) G__int(libp->para[2]), (size_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->insert((size_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (size_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->insert((size_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->insert((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (char) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->replace((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, *(string*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->replace((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, *(string*) libp->para[2].ref, (size_t) G__int(libp->para[3])
, (size_t) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->replace((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (size_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->replace((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((string*) G__getstructoffset())->replace((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2]), (char) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((const string*) G__getstructoffset())->operator[]((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((string*) G__getstructoffset())->operator[]((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((const string*) G__getstructoffset())->at((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((string*) G__getstructoffset())->at((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const string*) G__getstructoffset())->c_str());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const string*) G__getstructoffset())->data());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->length());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((string*) G__getstructoffset())->resize((size_t) G__int(libp->para[0]), (char) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((string*) G__getstructoffset())->resize((size_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((string*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((string*) G__getstructoffset())->reserve((size_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 104, (long) ((string*) G__getstructoffset())->copy((char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 104, (long) ((string*) G__getstructoffset())->copy((char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find((char) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find((char) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind((char) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->rfind((char) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of((char) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_of((char) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of((char) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_of((char) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of((char) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_first_not_of((char) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of(*(string*) libp->para[0].ref, (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of((const char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of((char) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->find_last_not_of((char) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const string* pobj;
         const string xobj = ((const string*) G__getstructoffset())->substr((size_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const string* pobj;
         const string xobj = ((const string*) G__getstructoffset())->substr((size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const string* pobj;
         const string xobj = ((const string*) G__getstructoffset())->substr();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const string*) G__getstructoffset())->compare(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const string*) G__getstructoffset())->compare((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string::iterator* pobj;
         string::iterator xobj = ((string*) G__getstructoffset())->begin();
         pobj = new string::iterator(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__Base2_53_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::const_iterator* pobj;
         const string::const_iterator xobj = ((const string*) G__getstructoffset())->begin();
         pobj = new string::const_iterator(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__Base2_53_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string::iterator* pobj;
         string::iterator xobj = ((string*) G__getstructoffset())->end();
         pobj = new string::iterator(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__Base2_53_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::const_iterator* pobj;
         const string::const_iterator xobj = ((const string*) G__getstructoffset())->end();
         pobj = new string::const_iterator(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__Base2_53_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((string*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const string*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_53_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const string*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef string G__Tstring;
static int G__G__Base2_53_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (string*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((string*) (soff+(sizeof(string)*i)))->~G__Tstring();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (string*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((string*) (soff))->~G__Tstring();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* string::iterator */
static int G__G__Base2_65_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new string::iterator[n];
     } else {
       p = new((void*) gvp) string::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new string::iterator;
     } else {
       p = new((void*) gvp) string::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new string::iterator(libp->para[0].ref ? *(const string::pointer*) libp->para[0].ref : *(const string::pointer*) (void*) (&G__Mlong(libp->para[0])));
   } else {
     p = new((void*) gvp) string::iterator(libp->para[0].ref ? *(const string::pointer*) libp->para[0].ref : *(const string::pointer*) (void*) (&G__Mlong(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::reference obj = ((const string::iterator*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const string::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::iterator& obj = ((string::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string::iterator* pobj;
         string::iterator xobj = ((string::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new string::iterator(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__Base2_65_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::iterator& obj = ((string::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string::iterator* pobj;
         string::iterator xobj = ((string::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new string::iterator(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__Base2_65_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::reference obj = ((const string::iterator*) G__getstructoffset())->operator[](*(string::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::iterator& obj = ((string::iterator*) G__getstructoffset())->operator+=(*(string::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::iterator* pobj;
         const string::iterator xobj = ((const string::iterator*) G__getstructoffset())->operator+(*(string::difference_type*) G__Longref(&libp->para[0]));
         pobj = new string::iterator(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__Base2_65_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::iterator& obj = ((string::iterator*) G__getstructoffset())->operator-=(*(string::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_65_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::iterator* pobj;
         const string::iterator xobj = ((const string::iterator*) G__getstructoffset())->operator-(*(string::difference_type*) G__Longref(&libp->para[0]));
         pobj = new string::iterator(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__Base2_65_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string::pointer& obj = ((const string::iterator*) G__getstructoffset())->base();
         result7->ref = (long) (&obj);
         G__letint(result7, 'C', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_65_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   string::iterator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new string::iterator(*(string::iterator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef string::iterator G__TstringcLcLiterator;
static int G__G__Base2_65_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (string::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((string::iterator*) (soff+(sizeof(string::iterator)*i)))->~G__TstringcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (string::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((string::iterator*) (soff))->~G__TstringcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_65_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   string::iterator* dest = (string::iterator*) G__getstructoffset();
   const string::iterator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStorage */
static int G__G__Base2_73_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TStorage::GetHeapBegin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TStorage::GetHeapEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::GetFreeHook());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::GetFreeHookData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TStorage::GetMaxBlockSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::Alloc((size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::Dealloc((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::ReAlloc((void*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::ReAlloc((void*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStorage::ReAllocChar((char*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) TStorage::ReAllocInt((Int_t*) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::ObjectAlloc((size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TStorage::ObjectAlloc((size_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::ObjectDealloc((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::ObjectDealloc((void*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::EnterStat((size_t) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::RemoveStat((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::PrintStatistics();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::SetMaxBlockSize((size_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::SetFreeHook((FreeHookFun_t) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::SetReAllocHooks((ReAllocFun_t) G__int(libp->para[0]), (ReAllocCFun_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::SetCustomNewDelete();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      TStorage::EnableStatistics((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TStorage::EnableStatistics((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TStorage::EnableStatistics();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TStorage::HasCustomNewDelete());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::AddToHeap((ULong_t) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TStorage::IsOnHeap((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStorage::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStorage::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStorage::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStorage::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TStorage*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStorage*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStorage*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStorage*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStorage::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStorage::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStorage::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_73_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStorage::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__G__Base2_73_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStorage *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStorage[n];
     } else {
       p = new((void*) gvp) TStorage[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStorage;
     } else {
       p = new((void*) gvp) TStorage;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStorage));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_73_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TStorage* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TStorage(*(TStorage*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStorage));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStorage G__TTStorage;
static int G__G__Base2_73_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TStorage*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStorage*) (soff+(sizeof(TStorage)*i)))->~G__TTStorage();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStorage*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStorage*) (soff))->~G__TTStorage();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_73_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStorage* dest = (TStorage*) G__getstructoffset();
   *dest = *(TStorage*) libp->para[0].ref;
   const TStorage& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTimer */
static int G__G__Base2_80_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTimer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTimer((Long_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTimer((Long_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTimer((Long_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TTimer((Long_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TTimer[n];
       } else {
         p = new((void*) gvp) TTimer[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TTimer;
       } else {
         p = new((void*) gvp) TTimer;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTimer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTimer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTimer(
(TObject*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TTimer(
(TObject*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTimer((TObject*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTimer((TObject*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTimer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTimer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTimer(
(const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TTimer(
(const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTimer((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTimer((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTimer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTimer*) G__getstructoffset())->CheckTimer(*(TTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTimer*) G__getstructoffset())->GetCommand());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TTimer*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTime* pobj;
         const TTime xobj = ((const TTimer*) G__getstructoffset())->GetTime();
         pobj = new TTime(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__Base2_80_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TTimer*) G__getstructoffset())->GetTimerID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTime* pobj;
         const TTime xobj = ((const TTimer*) G__getstructoffset())->GetAbsTime();
         pobj = new TTime(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__Base2_80_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTimer*) G__getstructoffset())->HasTimedOut());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTimer*) G__getstructoffset())->IsSync());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTimer*) G__getstructoffset())->IsAsync());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTimer*) G__getstructoffset())->IsInterruptingSyscalls());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->SetCommand((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->SetObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTimer*) G__getstructoffset())->SetInterruptSyscalls((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTimer*) G__getstructoffset())->SetInterruptSyscalls();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->SetTime((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTimer*) G__getstructoffset())->SetTimerID((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTimer*) G__getstructoffset())->SetTimerID();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTimer*) G__getstructoffset())->Start((Long_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTimer*) G__getstructoffset())->Start((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTimer*) G__getstructoffset())->Start();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->Stop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->TurnOn();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->TurnOff();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->Timeout();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTimer::SingleShot((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTimer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTimer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTimer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTimer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTimer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTimer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTimer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTimer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_80_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTimer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTimer G__TTTimer;
static int G__G__Base2_80_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTimer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTimer*) (soff+(sizeof(TTimer)*i)))->~G__TTTimer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTimer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTimer*) (soff))->~G__TTTimer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TProcessID */
static int G__G__Base2_86_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProcessID* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProcessID[n];
     } else {
       p = new((void*) gvp) TProcessID[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProcessID;
     } else {
       p = new((void*) gvp) TProcessID;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TProcessID));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProcessID*) G__getstructoffset())->CheckInit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProcessID*) G__getstructoffset())->DecrementCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProcessID*) G__getstructoffset())->IncrementCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TProcessID*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProcessID*) G__getstructoffset())->GetObjects());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TProcessID*) G__getstructoffset())->GetObjectWithID((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TProcessID*) G__getstructoffset())->PutObjectWithID((TObject*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TProcessID*) G__getstructoffset())->PutObjectWithID((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::AddProcessID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TProcessID::AssignID((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProcessID::Cleanup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TProcessID::GetNProcessIDs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::GetPID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::GetPIDs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::GetProcessID((UShort_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::GetProcessWithUID((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::GetProcessWithUID((UInt_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::GetSessionProcessID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TProcessID::GetObjectCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TProcessID::IsValid((TProcessID*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProcessID::SetObjectCount((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessID::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessID::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TProcessID::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProcessID::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProcessID*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessID::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProcessID::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessID::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_86_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProcessID::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TProcessID G__TTProcessID;
static int G__G__Base2_86_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TProcessID*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TProcessID*) (soff+(sizeof(TProcessID)*i)))->~G__TTProcessID();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TProcessID*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TProcessID*) (soff))->~G__TTProcessID();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRefCnt */
static int G__G__Base2_99_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefCnt* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefCnt((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TRefCnt((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TRefCnt[n];
       } else {
         p = new((void*) gvp) TRefCnt[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TRefCnt;
       } else {
         p = new((void*) gvp) TRefCnt;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRefCnt));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_99_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefCnt* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRefCnt((TRefCnt::EReferenceFlag) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TRefCnt((TRefCnt::EReferenceFlag) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRefCnt));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_99_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TRefCnt*) G__getstructoffset())->References());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_99_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefCnt*) G__getstructoffset())->SetRefCount((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_99_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefCnt*) G__getstructoffset())->AddReference();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_99_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TRefCnt*) G__getstructoffset())->RemoveReference());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_99_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TRefCnt* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TRefCnt(*(TRefCnt*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRefCnt));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRefCnt G__TTRefCnt;
static int G__G__Base2_99_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TRefCnt*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRefCnt*) (soff+(sizeof(TRefCnt)*i)))->~G__TTRefCnt();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRefCnt*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRefCnt*) (soff))->~G__TTRefCnt();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_99_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefCnt* dest = (TRefCnt*) G__getstructoffset();
   *dest = *(TRefCnt*) libp->para[0].ref;
   const TRefCnt& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRegexp */
static int G__G__Base2_102_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRegexp((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TRegexp((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRegexp((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TRegexp((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRegexp(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TRegexp(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRegexp(*(TRegexp*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TRegexp(*(TRegexp*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRegexp& obj = ((TRegexp*) G__getstructoffset())->operator=(*(TRegexp*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRegexp& obj = ((TRegexp*) G__getstructoffset())->operator=(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRegexp& obj = ((TRegexp*) G__getstructoffset())->operator=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TRegexp*) G__getstructoffset())->Index(*(TString*) libp->para[0].ref, (Ssiz_t*) G__int(libp->para[1])
, (Ssiz_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TRegexp*) G__getstructoffset())->Index(*(TString*) libp->para[0].ref, (Ssiz_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TRegexp*) G__getstructoffset())->Status());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRegexp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRegexp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRegexp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRegexp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRegexp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRegexp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRegexp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRegexp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRegexp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRegexp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRegexp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_102_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRegexp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRegexp G__TTRegexp;
static int G__G__Base2_102_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TRegexp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRegexp*) (soff+(sizeof(TRegexp)*i)))->~G__TTRegexp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRegexp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRegexp*) (soff))->~G__TTRegexp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPRegexp */
static int G__G__Base2_103_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPRegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPRegexp[n];
     } else {
       p = new((void*) gvp) TPRegexp[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPRegexp;
     } else {
       p = new((void*) gvp) TPRegexp;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPRegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPRegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPRegexp(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPRegexp(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPRegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPRegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPRegexp(*(TPRegexp*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPRegexp(*(TPRegexp*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPRegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TArrayI*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TPRegexp*) G__getstructoffset())->MatchS(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TPRegexp*) G__getstructoffset())->MatchS(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TPRegexp*) G__getstructoffset())->MatchS(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TPRegexp*) G__getstructoffset())->MatchS(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TPRegexp*) G__getstructoffset())->MatchB(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TPRegexp*) G__getstructoffset())->MatchB(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TPRegexp*) G__getstructoffset())->MatchB(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TPRegexp*) G__getstructoffset())->MatchB(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Substitute(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Substitute(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Substitute(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TPRegexp*) G__getstructoffset())->Substitute(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TPRegexp*) G__getstructoffset())->GetPattern();
         pobj = new TString(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__Base2_103_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TPRegexp*) G__getstructoffset())->GetModifiers();
         pobj = new TString(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__Base2_103_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TPRegexp& obj = ((TPRegexp*) G__getstructoffset())->operator=(*(TPRegexp*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPRegexp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPRegexp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPRegexp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPRegexp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPRegexp*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPRegexp*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPRegexp*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPRegexp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPRegexp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPRegexp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPRegexp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_103_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPRegexp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPRegexp G__TTPRegexp;
static int G__G__Base2_103_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TPRegexp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPRegexp*) (soff+(sizeof(TPRegexp)*i)))->~G__TTPRegexp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPRegexp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPRegexp*) (soff))->~G__TTPRegexp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSubString */
static int G__G__Base2_104_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSubString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSubString(*(TSubString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSubString(*(TSubString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSubString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString& obj = ((TSubString*) G__getstructoffset())->operator=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString& obj = ((TSubString*) G__getstructoffset())->operator=(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSubString& obj = ((TSubString*) G__getstructoffset())->operator=(*(TSubString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((TSubString*) G__getstructoffset())->operator()((Ssiz_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const char& obj = ((TSubString*) G__getstructoffset())->operator[]((Ssiz_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TSubString*) G__getstructoffset())->operator()((Ssiz_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TSubString*) G__getstructoffset())->operator[]((Ssiz_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSubString*) G__getstructoffset())->Data());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSubString*) G__getstructoffset())->Length());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSubString*) G__getstructoffset())->Start());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TSubString*) G__getstructoffset())->String();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSubString*) G__getstructoffset())->ToLower();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSubString*) G__getstructoffset())->ToUpper();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSubString*) G__getstructoffset())->IsNull());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_104_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSubString*) G__getstructoffset())->operator!());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSubString G__TTSubString;
static int G__G__Base2_104_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TSubString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSubString*) (soff+(sizeof(TSubString)*i)))->~G__TTSubString();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSubString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSubString*) (soff))->~G__TTSubString();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStringRef */
// automatic default constructor
static int G__G__Base2_106_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringRef *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStringRef[n];
     } else {
       p = new((void*) gvp) TStringRef[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStringRef;
     } else {
       p = new((void*) gvp) TStringRef;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringRef));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_106_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TStringRef* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TStringRef(*(TStringRef*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringRef));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStringRef G__TTStringRef;
static int G__G__Base2_106_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TStringRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStringRef*) (soff+(sizeof(TStringRef)*i)))->~G__TTStringRef();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStringRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStringRef*) (soff))->~G__TTStringRef();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_106_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringRef* dest = (TStringRef*) G__getstructoffset();
   *dest = *(TStringRef*) libp->para[0].ref;
   const TStringRef& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStringLong */
static int G__G__Base2_107_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStringLong[n];
     } else {
       p = new((void*) gvp) TStringLong[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStringLong;
     } else {
       p = new((void*) gvp) TStringLong;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong((Ssiz_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TStringLong((Ssiz_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TStringLong(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TStringLong((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TStringLong((const char*) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong((char) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TStringLong((char) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong((char) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TStringLong((char) G__int(libp->para[0]), (Ssiz_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TStringLong(*(TSubString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TStringLong(*(TSubString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStringLong::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStringLong::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStringLong::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStringLong::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStringLong*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStringLong::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStringLong::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStringLong::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_107_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStringLong::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_107_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TStringLong* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TStringLong(*(TStringLong*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStringLong G__TTStringLong;
static int G__G__Base2_107_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TStringLong*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStringLong*) (soff+(sizeof(TStringLong)*i)))->~G__TTStringLong();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStringLong*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStringLong*) (soff))->~G__TTStringLong();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_107_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringLong* dest = (TStringLong*) G__getstructoffset();
   *dest = *(TStringLong*) libp->para[0].ref;
   const TStringLong& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQConnection */
static int G__G__Base2_110_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQConnection* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQConnection[n];
     } else {
       p = new((void*) gvp) TQConnection[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQConnection;
     } else {
       p = new((void*) gvp) TQConnection;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQConnection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQConnection* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TQConnection(
(TClass*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TQConnection(
(TClass*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQConnection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQConnection* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TQConnection(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TQConnection(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQConnection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQConnection* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TQConnection(*(TQConnection*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TQConnection(*(TQConnection*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQConnection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TQConnection*) G__getstructoffset())->GetReceiver());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQConnection*) G__getstructoffset())->GetClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->ExecuteMethod();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((Int_t) G__int(libp->para[0]), *((va_list*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((Long_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((Long_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->ExecuteMethod((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQConnection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQConnection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQConnection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQConnection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQConnection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQConnection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQConnection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQConnection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_110_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQConnection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQConnection G__TTQConnection;
static int G__G__Base2_110_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TQConnection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQConnection*) (soff+(sizeof(TQConnection)*i)))->~G__TTQConnection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQConnection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQConnection*) (soff))->~G__TTQConnection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQObject */
static int G__G__Base2_111_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQObject[n];
     } else {
       p = new((void*) gvp) TQObject[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQObject;
     } else {
       p = new((void*) gvp) TQObject;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQObject*) G__getstructoffset())->GetListOfClassSignals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQObject*) G__getstructoffset())->GetListOfSignals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQObject*) G__getstructoffset())->GetListOfConnections());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQObject*) G__getstructoffset())->AreSignalsBlocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TQObject*) G__getstructoffset())->BlockSignals((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->CollectClassSignalLists(*(TList*) libp->para[0].ref, (TClass*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 2);
      ((TQObject*) G__getstructoffset())->EmitVA((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->EmitVA((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *((va_list*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Long_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Short_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (UShort_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (ULong64_t) G__ULonglong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Emit((const char*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TQObject*) G__getstructoffset())->Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TQObject*) G__getstructoffset())->Disconnect((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TQObject*) G__getstructoffset())->Disconnect((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TQObject*) G__getstructoffset())->Disconnect((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TQObject*) G__getstructoffset())->Disconnect());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TQObject*) G__getstructoffset())->HighPriority((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TQObject*) G__getstructoffset())->HighPriority((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TQObject*) G__getstructoffset())->LowPriority((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TQObject*) G__getstructoffset())->LowPriority((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQObject*) G__getstructoffset())->HasConnection((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQObject*) G__getstructoffset())->NumberOfSignals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQObject*) G__getstructoffset())->NumberOfConnections());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Connected((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Disconnected((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Destroyed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->ChangedBy((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Message((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TQObject::Connect((TQObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TQObject::Connect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) TQObject::Disconnect((TQObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) TQObject::Disconnect((TQObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TQObject::Disconnect((TQObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) TQObject::Disconnect((TQObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) TQObject::Disconnect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) TQObject::Disconnect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TQObject::Disconnect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TQObject::AreAllSignalsBlocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TQObject::BlockAllSignals((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQObject::LoadRQ_OBJECT();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQObject*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_111_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQObject G__TTQObject;
static int G__G__Base2_111_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TQObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQObject*) (soff+(sizeof(TQObject)*i)))->~G__TTQObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQObject*) (soff))->~G__TTQObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQObjSender */
static int G__G__Base2_112_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQObjSender* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQObjSender[n];
     } else {
       p = new((void*) gvp) TQObjSender[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQObjSender;
     } else {
       p = new((void*) gvp) TQObjSender;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQObjSender));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObjSender*) G__getstructoffset())->SetSender((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TQObjSender*) G__getstructoffset())->SetSenderClassName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TQObjSender*) G__getstructoffset())->SetSenderClassName();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQObjSender::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQObjSender::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQObjSender::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQObjSender::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQObjSender*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQObjSender::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQObjSender::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQObjSender::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_112_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQObjSender::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQObjSender G__TTQObjSender;
static int G__G__Base2_112_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TQObjSender*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQObjSender*) (soff+(sizeof(TQObjSender)*i)))->~G__TTQObjSender();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQObjSender*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQObjSender*) (soff))->~G__TTQObjSender();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSignalHandler */
static int G__G__Base2_115_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSignalHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSignalHandler((ESignals) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSignalHandler((ESignals) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSignalHandler((ESignals) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSignalHandler((ESignals) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSignalHandler*) G__getstructoffset())->Delay();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSignalHandler*) G__getstructoffset())->HandleDelayedSignal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSignalHandler*) G__getstructoffset())->GetSignal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSignalHandler*) G__getstructoffset())->SetSignal((ESignals) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSignalHandler*) G__getstructoffset())->IsSync());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSignalHandler*) G__getstructoffset())->IsAsync());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSignalHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSignalHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSignalHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSignalHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSignalHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSignalHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSignalHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSignalHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_115_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSignalHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSignalHandler G__TTSignalHandler;
static int G__G__Base2_115_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSignalHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSignalHandler*) (soff+(sizeof(TSignalHandler)*i)))->~G__TTSignalHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSignalHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSignalHandler*) (soff))->~G__TTSignalHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStopwatch */
static int G__G__Base2_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStopwatch* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStopwatch[n];
     } else {
       p = new((void*) gvp) TStopwatch[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStopwatch;
     } else {
       p = new((void*) gvp) TStopwatch;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStopwatch));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStopwatch*) G__getstructoffset())->Start((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStopwatch*) G__getstructoffset())->Start();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStopwatch*) G__getstructoffset())->Stop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStopwatch*) G__getstructoffset())->Continue();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TStopwatch*) G__getstructoffset())->Counter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TStopwatch*) G__getstructoffset())->RealTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStopwatch*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStopwatch*) G__getstructoffset())->ResetCpuTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStopwatch*) G__getstructoffset())->ResetCpuTime();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TStopwatch*) G__getstructoffset())->ResetRealTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TStopwatch*) G__getstructoffset())->ResetRealTime();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TStopwatch*) G__getstructoffset())->CpuTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStopwatch::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStopwatch::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStopwatch::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStopwatch::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStopwatch*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStopwatch::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStopwatch::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStopwatch::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_129_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStopwatch::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_129_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TStopwatch* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TStopwatch(*(TStopwatch*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStopwatch));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStopwatch G__TTStopwatch;
static int G__G__Base2_129_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStopwatch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStopwatch*) (soff+(sizeof(TStopwatch)*i)))->~G__TTStopwatch();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStopwatch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStopwatch*) (soff))->~G__TTStopwatch();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_129_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStopwatch* dest = (TStopwatch*) G__getstructoffset();
   *dest = *(TStopwatch*) libp->para[0].ref;
   const TStopwatch& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TUUID */
static int G__G__Base2_173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUUID* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUUID[n];
     } else {
       p = new((void*) gvp) TUUID[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUUID;
     } else {
       p = new((void*) gvp) TUUID;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TUUID));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUUID* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TUUID((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TUUID((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TUUID));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TUUID*) G__getstructoffset())->AsString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TUUID*) G__getstructoffset())->Compare(*(TUUID*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const TUUID*) G__getstructoffset())->Hash());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TUUID*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TInetAddress* pobj;
         const TInetAddress xobj = ((const TUUID*) G__getstructoffset())->GetHostAddress();
         pobj = new TInetAddress(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__Base2_173_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime* pobj;
         const TDatime xobj = ((const TUUID*) G__getstructoffset())->GetTime();
         pobj = new TDatime(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__Base2_173_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TUUID*) G__getstructoffset())->GetUUID((UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->SetUUID((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TUUID*) G__getstructoffset())->GetUUIDNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->SetUUIDNumber((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->StreamerV1(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->FillBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->ReadBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TUUID*) G__getstructoffset())->Sizeof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TUUID::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUUID::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TUUID::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TUUID::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TUUID*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUUID*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUUID::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TUUID::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUUID::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_173_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TUUID::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_173_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TUUID* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TUUID(*(TUUID*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TUUID));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TUUID G__TTUUID;
static int G__G__Base2_173_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TUUID*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TUUID*) (soff+(sizeof(TUUID)*i)))->~G__TTUUID();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TUUID*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TUUID*) (soff))->~G__TTUUID();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_173_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUUID* dest = (TUUID*) G__getstructoffset();
   *dest = *(TUUID*) libp->para[0].ref;
   const TUUID& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TExec */
static int G__G__Base2_187_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TExec* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TExec[n];
     } else {
       p = new((void*) gvp) TExec[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TExec;
     } else {
       p = new((void*) gvp) TExec;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TExec));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TExec* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TExec((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TExec((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TExec));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TExec* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TExec(*(TExec*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TExec(*(TExec*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TExec));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TExec*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TExec*) G__getstructoffset())->Exec();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExec*) G__getstructoffset())->SetAction((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TExec::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TExec::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TExec::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TExec::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExec*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TExec::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TExec::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TExec::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_187_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TExec::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TExec G__TTExec;
static int G__G__Base2_187_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TExec*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TExec*) (soff+(sizeof(TExec)*i)))->~G__TTExec();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TExec*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TExec*) (soff))->~G__TTExec();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_187_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TExec* dest = (TExec*) G__getstructoffset();
   *dest = *(TExec*) libp->para[0].ref;
   const TExec& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFolder */
static int G__G__Base2_188_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFolder* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFolder[n];
     } else {
       p = new((void*) gvp) TFolder[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFolder;
     } else {
       p = new((void*) gvp) TFolder;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TFolder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFolder* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFolder((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TFolder((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TFolder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFolder*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TFolder*) G__getstructoffset())->AddFolder((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TCollection*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TFolder*) G__getstructoffset())->AddFolder((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TFolder*) G__getstructoffset())->FindFullPathName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TFolder*) G__getstructoffset())->FindFullPathName((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFolder*) G__getstructoffset())->FindObjectAny((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFolder*) G__getstructoffset())->GetListOfFolders());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TFolder*) G__getstructoffset())->IsOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFolder*) G__getstructoffset())->Occurence((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFolder*) G__getstructoffset())->Remove((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TFolder*) G__getstructoffset())->SetOwner((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TFolder*) G__getstructoffset())->SetOwner();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFolder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFolder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFolder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFolder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFolder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFolder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFolder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFolder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_188_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFolder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFolder G__TTFolder;
static int G__G__Base2_188_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFolder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFolder*) (soff+(sizeof(TFolder)*i)))->~G__TTFolder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFolder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFolder*) (soff))->~G__TTFolder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TObjString */
static int G__G__Base2_191_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObjString* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TObjString((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TObjString((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TObjString[n];
       } else {
         p = new((void*) gvp) TObjString[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TObjString;
       } else {
         p = new((void*) gvp) TObjString;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TObjString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObjString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TObjString(*(TObjString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TObjString(*(TObjString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TObjString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObjString*) G__getstructoffset())->FillBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObjString*) G__getstructoffset())->ReadBuffer(libp->para[0].ref ? *(char**) libp->para[0].ref : *(char**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObjString*) G__getstructoffset())->SetString((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TObjString*) G__getstructoffset())->GetString();
         pobj = new TString(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__Base2_191_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TObjString*) G__getstructoffset())->Sizeof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((TObjString*) G__getstructoffset())->String();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TObjString::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TObjString::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TObjString::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObjString::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObjString*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TObjString::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TObjString::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TObjString::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_191_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TObjString::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TObjString G__TTObjString;
static int G__G__Base2_191_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TObjString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TObjString*) (soff+(sizeof(TObjString)*i)))->~G__TTObjString();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TObjString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TObjString*) (soff))->~G__TTObjString();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_191_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObjString* dest = (TObjString*) G__getstructoffset();
   *dest = *(TObjString*) libp->para[0].ref;
   const TObjString& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMD5 */
static int G__G__Base2_192_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMD5* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMD5[n];
     } else {
       p = new((void*) gvp) TMD5[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMD5;
     } else {
       p = new((void*) gvp) TMD5;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMD5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMD5* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMD5((const UChar_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TMD5((const UChar_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMD5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMD5* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMD5(*(TMD5*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMD5(*(TMD5*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMD5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMD5& obj = ((TMD5*) G__getstructoffset())->operator=(*(TMD5*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMD5*) G__getstructoffset())->Update((const UChar_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMD5*) G__getstructoffset())->Final();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMD5*) G__getstructoffset())->Final((UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMD5*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMD5*) G__getstructoffset())->AsString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMD5*) G__getstructoffset())->SetDigest((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMD5::ReadChecksum((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMD5::WriteChecksum((const char*) G__int(libp->para[0]), (TMD5*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMD5::FileChecksum((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMD5::FileChecksum((const char*) G__int(libp->para[0]), (UChar_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMD5::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMD5::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMD5::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMD5::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMD5*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMD5*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMD5*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMD5*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMD5::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMD5::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMD5::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_192_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMD5::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMD5 G__TTMD5;
static int G__G__Base2_192_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TMD5*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMD5*) (soff+(sizeof(TMD5)*i)))->~G__TTMD5();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMD5*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMD5*) (soff))->~G__TTMD5();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMacro */
static int G__G__Base2_193_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMacro* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMacro[n];
     } else {
       p = new((void*) gvp) TMacro[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMacro;
     } else {
       p = new((void*) gvp) TMacro;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMacro));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMacro* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMacro(*(TMacro*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMacro(*(TMacro*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMacro));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMacro* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMacro((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMacro((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMacro((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMacro((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMacro));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMacro& obj = ((TMacro*) G__getstructoffset())->operator=(*(TMacro*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMacro*) G__getstructoffset())->AddLine((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMacro*) G__getstructoffset())->Checksum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMacro*) G__getstructoffset())->GetLineWith((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TMacro*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TMacro*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 108, (long) ((TMacro*) G__getstructoffset())->Exec());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMacro*) G__getstructoffset())->GetListOfLines());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMacro*) G__getstructoffset())->ReadFile((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMacro*) G__getstructoffset())->SaveSource((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMacro*) G__getstructoffset())->SetParams((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMacro*) G__getstructoffset())->SetParams();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMacro::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMacro::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMacro::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMacro::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMacro*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMacro::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMacro::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMacro::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_193_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMacro::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMacro G__TTMacro;
static int G__G__Base2_193_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMacro*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMacro*) (soff+(sizeof(TMacro)*i)))->~G__TTMacro();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMacro*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMacro*) (soff))->~G__TTMacro();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMessageHandler */
static int G__G__Base2_194_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMessageHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMessageHandler((TClass*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMessageHandler((TClass*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMessageHandler((TClass*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMessageHandler((TClass*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMessageHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMessageHandler((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMessageHandler((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMessageHandler((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMessageHandler((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMessageHandler*) G__getstructoffset())->GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMessageHandler*) G__getstructoffset())->GetMessageCount((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMessageHandler*) G__getstructoffset())->GetTotalMessageCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMessageHandler*) G__getstructoffset())->HandleDerived());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->HandleMessage((Int_t) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->Add();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->Remove();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->Added();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->Removed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->Notified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMessageHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMessageHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMessageHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMessageHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMessageHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMessageHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMessageHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMessageHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_194_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMessageHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMessageHandler G__TTMessageHandler;
static int G__G__Base2_194_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMessageHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMessageHandler*) (soff+(sizeof(TMessageHandler)*i)))->~G__TTMessageHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMessageHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMessageHandler*) (soff))->~G__TTMessageHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPluginManager */
static int G__G__Base2_197_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPluginManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPluginManager[n];
     } else {
       p = new((void*) gvp) TPluginManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPluginManager;
     } else {
       p = new((void*) gvp) TPluginManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPluginManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPluginManager*) G__getstructoffset())->LoadHandlersFromEnv((TEnv*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPluginManager*) G__getstructoffset())->LoadHandlersFromPluginDirs((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPluginManager*) G__getstructoffset())->LoadHandlersFromPluginDirs();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TPluginManager*) G__getstructoffset())->AddHandler((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TPluginManager*) G__getstructoffset())->AddHandler((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TPluginManager*) G__getstructoffset())->AddHandler((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TPluginManager*) G__getstructoffset())->RemoveHandler((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPluginManager*) G__getstructoffset())->RemoveHandler((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TPluginManager*) G__getstructoffset())->FindHandler((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TPluginManager*) G__getstructoffset())->FindHandler((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TPluginManager*) G__getstructoffset())->WritePluginMacros((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TPluginManager*) G__getstructoffset())->WritePluginMacros((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TPluginManager*) G__getstructoffset())->WritePluginRecords((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TPluginManager*) G__getstructoffset())->WritePluginRecords((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPluginManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPluginManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPluginManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPluginManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPluginManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPluginManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPluginManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPluginManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_197_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPluginManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPluginManager G__TTPluginManager;
static int G__G__Base2_197_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPluginManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPluginManager*) (soff+(sizeof(TPluginManager)*i)))->~G__TTPluginManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPluginManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPluginManager*) (soff))->~G__TTPluginManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPluginHandler */
static int G__G__Base2_198_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TPluginHandler*) G__getstructoffset())->GetClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPluginHandler*) G__getstructoffset())->CheckPlugin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPluginHandler*) G__getstructoffset())->LoadPlugin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      G__letint(result7, 108, (long) ((TPluginHandler*) G__getstructoffset())->ExecPlugin((Int_t) G__int(libp->para[0]), G__va_arg_bufobj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPluginHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPluginHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPluginHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPluginHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPluginHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPluginHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPluginHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPluginHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_198_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPluginHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPoint */
static int G__G__Base2_199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoint* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPoint[n];
     } else {
       p = new((void*) gvp) TPoint[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPoint;
     } else {
       p = new((void*) gvp) TPoint;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPoint));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoint* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPoint((SCoord_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TPoint((SCoord_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPoint));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPoint* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPoint((SCoord_t) G__int(libp->para[0]), (SCoord_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TPoint((SCoord_t) G__int(libp->para[0]), (SCoord_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPoint));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TPoint*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TPoint*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoint*) G__getstructoffset())->SetX((SCoord_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPoint*) G__getstructoffset())->SetY((SCoord_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_199_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TPoint& obj = ((TPoint*) G__getstructoffset())->operator=(*(TPoint*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_199_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TPoint* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TPoint(*(TPoint*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPoint));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPoint G__TTPoint;
static int G__G__Base2_199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TPoint*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPoint*) (soff+(sizeof(TPoint)*i)))->~G__TTPoint();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPoint*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPoint*) (soff))->~G__TTPoint();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPMERegexp */
static int G__G__Base2_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPMERegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp[n];
     } else {
       p = new((void*) gvp) TPMERegexp[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp;
     } else {
       p = new((void*) gvp) TPMERegexp;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPMERegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp(
*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TPMERegexp(
*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TPMERegexp(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp(*(TString*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TPMERegexp(*(TString*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPMERegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp(
*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TPMERegexp(
*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPMERegexp(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TPMERegexp(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPMERegexp* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPMERegexp(*(TPMERegexp*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPMERegexp(*(TPMERegexp*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TPMERegexp*) G__getstructoffset())->Reset(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TPMERegexp*) G__getstructoffset())->Reset(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TPMERegexp*) G__getstructoffset())->Reset(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TPMERegexp*) G__getstructoffset())->Reset(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TPMERegexp*) G__getstructoffset())->Reset(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPMERegexp*) G__getstructoffset())->GetNMaxMatches());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPMERegexp*) G__getstructoffset())->SetNMaxMatches((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPMERegexp*) G__getstructoffset())->GetGlobalPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPMERegexp*) G__getstructoffset())->AssignGlobalState(*(TPMERegexp*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPMERegexp*) G__getstructoffset())->ResetGlobalState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TPMERegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TPMERegexp*) G__getstructoffset())->Match(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TPMERegexp*) G__getstructoffset())->Split(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TPMERegexp*) G__getstructoffset())->Split(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TPMERegexp*) G__getstructoffset())->Substitute(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TPMERegexp*) G__getstructoffset())->Substitute(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPMERegexp*) G__getstructoffset())->NMatches());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TPMERegexp*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TString(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__Base2_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPMERegexp*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPMERegexp*) G__getstructoffset())->Print();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPMERegexp::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPMERegexp::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPMERegexp::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPMERegexp::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPMERegexp*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPMERegexp::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPMERegexp::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPMERegexp::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_202_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPMERegexp::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPMERegexp G__TTPMERegexp;
static int G__G__Base2_202_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TPMERegexp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPMERegexp*) (soff+(sizeof(TPMERegexp)*i)))->~G__TTPMERegexp();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPMERegexp*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPMERegexp*) (soff))->~G__TTPMERegexp();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStringToken */
static int G__G__Base2_203_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TStringToken* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStringToken(
*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TStringToken(
*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TStringToken(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TStringToken(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringToken));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TStringToken*) G__getstructoffset())->NextToken());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TStringToken*) G__getstructoffset())->AtEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStringToken::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStringToken::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStringToken::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStringToken::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStringToken*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStringToken::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStringToken::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStringToken::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_203_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStringToken::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_203_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TStringToken* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TStringToken(*(TStringToken*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TStringToken));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStringToken G__TTStringToken;
static int G__G__Base2_203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TStringToken*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStringToken*) (soff+(sizeof(TStringToken)*i)))->~G__TTStringToken();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStringToken*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStringToken*) (soff))->~G__TTStringToken();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TProcessUUID */
static int G__G__Base2_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProcessUUID* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProcessUUID[n];
     } else {
       p = new((void*) gvp) TProcessUUID[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProcessUUID;
     } else {
       p = new((void*) gvp) TProcessUUID;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TProcessUUID*) G__getstructoffset())->AddUUID(*(TUUID*) libp->para[0].ref, (TObject*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TProcessUUID*) G__getstructoffset())->AddUUID((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProcessUUID*) G__getstructoffset())->FindUUID((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProcessUUID*) G__getstructoffset())->GetActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProcessUUID*) G__getstructoffset())->GetUUIDs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProcessUUID*) G__getstructoffset())->RemoveUUID((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessUUID::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessUUID::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TProcessUUID::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProcessUUID::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProcessUUID*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessUUID::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProcessUUID::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessUUID::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_207_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProcessUUID::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TProcessUUID G__TTProcessUUID;
static int G__G__Base2_207_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TProcessUUID*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TProcessUUID*) (soff+(sizeof(TProcessUUID)*i)))->~G__TTProcessUUID();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TProcessUUID*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TProcessUUID*) (soff))->~G__TTProcessUUID();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQClass */
static int G__G__Base2_231_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQClass* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TQClass(
(const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
, (ShowMembersFunc_t) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQClass));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQClass::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQClass::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQClass::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQClass::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQClass*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQClass::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQClass::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQClass::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_231_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQClass::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQClass G__TTQClass;
static int G__G__Base2_231_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TQClass*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQClass*) (soff+(sizeof(TQClass)*i)))->~G__TTQClass();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQClass*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQClass*) (soff))->~G__TTQClass();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQCommand */
static int G__G__Base2_233_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQCommand* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TQCommand(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TQCommand(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TQCommand((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TQCommand((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TQCommand[n];
       } else {
         p = new((void*) gvp) TQCommand[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TQCommand;
       } else {
         p = new((void*) gvp) TQCommand;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQCommand));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQCommand* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand(
(TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TQCommand(
(TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TQCommand((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQCommand((TObject*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TQCommand((TObject*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQCommand));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQCommand* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TQCommand(*(TQCommand*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TQCommand(*(TQCommand*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQCommand));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TQCommand*) G__getstructoffset())->Redo((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TQCommand*) G__getstructoffset())->Redo();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TQCommand*) G__getstructoffset())->Undo((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TQCommand*) G__getstructoffset())->Undo();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      ((TQCommand*) G__getstructoffset())->SetArgs((Int_t) G__int(libp->para[0]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      ((TQCommand*) G__getstructoffset())->SetUndoArgs((Int_t) G__int(libp->para[0]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      ((TQCommand*) G__getstructoffset())->SetRedoArgs((Int_t) G__int(libp->para[0]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->CanMerge((TQCommand*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQCommand*) G__getstructoffset())->Merge((TQCommand*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->CanCompress((TQCommand*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQCommand*) G__getstructoffset())->Compress((TQCommand*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->IsSetter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->CanRedo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->CanUndo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQCommand*) G__getstructoffset())->GetRedoName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQCommand*) G__getstructoffset())->GetUndoName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQCommand*) G__getstructoffset())->GetRedo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQCommand*) G__getstructoffset())->GetUndo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 76, (long) ((const TQCommand*) G__getstructoffset())->GetRedoArgs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 76, (long) ((const TQCommand*) G__getstructoffset())->GetUndoArgs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQCommand*) G__getstructoffset())->GetNRargs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQCommand*) G__getstructoffset())->GetNUargs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TQCommand*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQCommand*) G__getstructoffset())->GetStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->IsMacro());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->IsUndoing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->IsRedoing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQCommand*) G__getstructoffset())->IsExecuting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQCommand*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQCommand::GetCommand());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQCommand::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQCommand::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQCommand::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQCommand::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQCommand*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQCommand::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQCommand::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQCommand::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_233_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQCommand::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQCommand G__TTQCommand;
static int G__G__Base2_233_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TQCommand*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQCommand*) (soff+(sizeof(TQCommand)*i)))->~G__TTQCommand();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQCommand*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQCommand*) (soff))->~G__TTQCommand();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQUndoManager */
static int G__G__Base2_234_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQUndoManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQUndoManager[n];
     } else {
       p = new((void*) gvp) TQUndoManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQUndoManager;
     } else {
       p = new((void*) gvp) TQUndoManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TQUndoManager*) G__getstructoffset())->SetLogging((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TQUndoManager*) G__getstructoffset())->SetLogging();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQUndoManager*) G__getstructoffset())->IsLogging());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQUndoManager*) G__getstructoffset())->GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQUndoManager*) G__getstructoffset())->GetCursor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TQUndoManager*) G__getstructoffset())->GetLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQUndoManager*) G__getstructoffset())->SetLimit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQUndoManager*) G__getstructoffset())->CurrentChanged((TQCommand*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQUndoManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQUndoManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQUndoManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQUndoManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQUndoManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQUndoManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQUndoManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQUndoManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_234_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQUndoManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQUndoManager G__TTQUndoManager;
static int G__G__Base2_234_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TQUndoManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQUndoManager*) (soff+(sizeof(TQUndoManager)*i)))->~G__TTQUndoManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQUndoManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQUndoManager*) (soff))->~G__TTQUndoManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRef */
static int G__G__Base2_236_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRef[n];
     } else {
       p = new((void*) gvp) TRef[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRef;
     } else {
       p = new((void*) gvp) TRef;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRef((TObject*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TRef((TObject*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRef(*(TRef*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TRef(*(TRef*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRef*) G__getstructoffset())->operator=((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRef& obj = ((TRef*) G__getstructoffset())->operator=(*(TRef*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRef*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRef*) G__getstructoffset())->GetPID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TRef*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRef*) G__getstructoffset())->SetAction((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRef*) G__getstructoffset())->SetAction((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRef::SetObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRef::SetStaticObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRef::AddExec((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRef::GetListOfExecs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRef::GetStaticObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRef::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRef::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRef::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRef::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRef*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRef::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRef::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRef::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_236_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRef::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRef G__TTRef;
static int G__G__Base2_236_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRef*) (soff+(sizeof(TRef)*i)))->~G__TTRef();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRef*) (soff))->~G__TTRef();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSystemFile */
static int G__G__Base2_239_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSystemFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSystemFile[n];
     } else {
       p = new((void*) gvp) TSystemFile[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSystemFile;
     } else {
       p = new((void*) gvp) TSystemFile;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSystemFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSystemFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSystemFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TSystemFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSystemFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->Rename((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->Delete();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->Copy((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->Move((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->Edit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((const TSystemFile*) G__getstructoffset())->IsDirectory((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((const TSystemFile*) G__getstructoffset())->IsDirectory());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->SetIconName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSystemFile::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystemFile::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSystemFile::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSystemFile::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystemFile::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystemFile::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystemFile::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_239_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystemFile::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_239_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TSystemFile* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSystemFile(*(TSystemFile*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSystemFile));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSystemFile G__TTSystemFile;
static int G__G__Base2_239_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSystemFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSystemFile*) (soff+(sizeof(TSystemFile)*i)))->~G__TTSystemFile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSystemFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSystemFile*) (soff))->~G__TTSystemFile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_239_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSystemFile* dest = (TSystemFile*) G__getstructoffset();
   *dest = *(TSystemFile*) libp->para[0].ref;
   const TSystemFile& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSystemDirectory */
static int G__G__Base2_241_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSystemDirectory* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSystemDirectory[n];
     } else {
       p = new((void*) gvp) TSystemDirectory[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSystemDirectory;
     } else {
       p = new((void*) gvp) TSystemDirectory;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSystemDirectory* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSystemDirectory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TSystemDirectory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSystemDirectory*) G__getstructoffset())->GetListOfFiles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemDirectory*) G__getstructoffset())->SetDirectory((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSystemDirectory::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystemDirectory::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSystemDirectory::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSystemDirectory::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystemDirectory*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystemDirectory::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystemDirectory::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystemDirectory::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_241_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystemDirectory::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSystemDirectory G__TTSystemDirectory;
static int G__G__Base2_241_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSystemDirectory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSystemDirectory*) (soff+(sizeof(TSystemDirectory)*i)))->~G__TTSystemDirectory();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSystemDirectory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSystemDirectory*) (soff))->~G__TTSystemDirectory();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSystem */
static int G__G__Base2_242_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSystem* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSystem((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSystem((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSystem((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSystem((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TSystem[n];
       } else {
         p = new((void*) gvp) TSystem[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TSystem;
       } else {
         p = new((void*) gvp) TSystem;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TSystem));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->Init());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetProgname((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetDisplay();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetErrorStr((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetErrorStr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->RemoveOnExit((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->HostName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->NotifyApplicationCreated();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystem::GetErrno());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSystem::ResetErrno();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TSystem*) G__getstructoffset())->Beep((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TSystem*) G__getstructoffset())->Beep((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->Beep((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSystem*) G__getstructoffset())->Beep();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TSystem*) G__getstructoffset())->GetBeepDefaults(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Run();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->ProcessEvents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSystem*) G__getstructoffset())->DispatchOneEvent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSystem*) G__getstructoffset())->DispatchOneEvent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->ExitLoop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSystem*) G__getstructoffset())->InControl());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->InnerLoop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Select((TList*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Select((TFileHandler*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddSignalHandler((TSignalHandler*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->RemoveSignalHandler((TSignalHandler*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TSystem*) G__getstructoffset())->ResetSignal((ESignals) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->ResetSignal((ESignals) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TSystem*) G__getstructoffset())->IgnoreSignal((ESignals) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->IgnoreSignal((ESignals) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSystem*) G__getstructoffset())->IgnoreInterrupt((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSystem*) G__getstructoffset())->IgnoreInterrupt();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSystem*) G__getstructoffset())->GetListOfSignalHandlers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddFileHandler((TFileHandler*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->RemoveFileHandler((TFileHandler*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSystem*) G__getstructoffset())->GetListOfFileHandlers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddStdExceptionHandler((TStdExceptionHandler*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->RemoveStdExceptionHandler((TStdExceptionHandler*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSystem*) G__getstructoffset())->GetListOfStdExceptionHandlers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetFPEMask());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->SetFPEMask((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->SetFPEMask());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = ((TSystem*) G__getstructoffset())->Now();
         pobj = new TTime(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__Base2_242_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSystem*) G__getstructoffset())->GetListOfTimers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddTimer((TTimer*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->RemoveTimer((TTimer*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->ResetTimer((TTimer*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TSystem*) G__getstructoffset())->NextTimeOut((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Sleep((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 69, (long) ((TSystem*) G__getstructoffset())->OpenPipe((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->ClosePipe((FILE*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TSystem*) G__getstructoffset())->GetFromPipe((const char*) G__int(libp->para[0]));
         pobj = new TString(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__Base2_242_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TSystem*) G__getstructoffset())->Exit((int) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->Exit((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSystem*) G__getstructoffset())->Abort((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSystem*) G__getstructoffset())->Abort();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetPid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->StackTrace();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->MakeDirectory((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TSystem*) G__getstructoffset())->OpenDirectory((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->FreeDirectory((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetDirEntry((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TSystem*) G__getstructoffset())->GetDirPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->ChangeDirectory((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->WorkingDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->HomeDirectory((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->HomeDirectory());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->mkdir((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->mkdir((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->cd((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->pwd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->TempDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 69, (long) ((TSystem*) G__getstructoffset())->TempFileName(*(TString*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 69, (long) ((TSystem*) G__getstructoffset())->TempFileName(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->BaseName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->DirName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->ConcatFileName((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->IsAbsoluteFileName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->IsFileInIncludePath((const char*) G__int(libp->para[0]), (char**) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->IsFileInIncludePath((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->PrependPathName((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->ExpandPathName(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->ExpandPathName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->AccessPathName((const char*) G__int(libp->para[0]), (EAccessMode) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->AccessPathName((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSystem*) G__getstructoffset())->IsPathLocal((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CopyFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CopyFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Rename((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Link((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Symlink((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Unlink((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), (Long_t*) G__int(libp->para[1])
, (Long_t*) G__int(libp->para[2]), (Long_t*) G__int(libp->para[3])
, (Long_t*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), (Long_t*) G__int(libp->para[1])
, (Long64_t*) G__int(libp->para[2]), (Long_t*) G__int(libp->para[3])
, (Long_t*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetPathInfo((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetFsInfo((const char*) G__int(libp->para[0]), (Long_t*) G__int(libp->para[1])
, (Long_t*) G__int(libp->para[2]), (Long_t*) G__int(libp->para[3])
, (Long_t*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Chmod((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Umask((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Utime((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->UnixPathName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->FindFile((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (EAccessMode) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->FindFile((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->Which((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (EAccessMode) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->Which((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSystem*) G__getstructoffset())->GetVolumes((Option_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetUid((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetUid());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetGid((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetGid());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetEffectiveUid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetEffectiveGid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->GetUserInfo((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->GetUserInfo((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->GetUserInfo());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->GetGroupInfo((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->GetGroupInfo((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TSystem*) G__getstructoffset())->GetGroupInfo());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Setenv((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Unsetenv((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->Getenv((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Openlog((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (ELogFacility) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Syslog((ELogLevel) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Closelog();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->RedirectOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (RedirectHandle_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->RedirectOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->RedirectOutput((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->ShowOutput((RedirectHandle_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddDynamicPath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetDynamicPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetDynamicPath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->DynamicPathName((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->DynamicPathName((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TSystem*) G__getstructoffset())->DynFindSymbol((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->Load((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->Unload((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TSystem*) G__getstructoffset())->ListSymbols((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->ListSymbols((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSystem*) G__getstructoffset())->ListLibraries((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSystem*) G__getstructoffset())->ListLibraries();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetLibraries((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetLibraries((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetLibraries((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetLibraries());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TInetAddress* pobj;
         TInetAddress xobj = ((TSystem*) G__getstructoffset())->GetHostByName((const char*) G__int(libp->para[0]));
         pobj = new TInetAddress(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__Base2_242_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TInetAddress* pobj;
         TInetAddress xobj = ((TSystem*) G__getstructoffset())->GetPeerName((int) G__int(libp->para[0]));
         pobj = new TInetAddress(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__Base2_242_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TInetAddress* pobj;
         TInetAddress xobj = ((TSystem*) G__getstructoffset())->GetSockName((int) G__int(libp->para[0]));
         pobj = new TInetAddress(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__Base2_242_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetServiceByName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetServiceByPort((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->OpenConnection((const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->OpenConnection((const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->AnnounceTcpService((int) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->AnnounceTcpService((int) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->AnnounceUnixService((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->AnnounceUnixService((const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->AcceptConnection((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TSystem*) G__getstructoffset())->CloseConnection((int) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->CloseConnection((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->RecvRaw((int) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->SendRaw((int) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->RecvBuf((int) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->SendBuf((int) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->SetSockOpt((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->GetSockOpt((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetSysInfo((SysInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetCpuInfo((CpuInfo_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetCpuInfo((CpuInfo_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetMemInfo((MemInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetProcInfo((ProcInfo_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddIncludePath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->AddLinkedLibs((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CompileMacro((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CompileMacro((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CompileMacro((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CompileMacro((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TSystem*) G__getstructoffset())->CompileMacro((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetAclicProperties());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetBuildArch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetBuildCompiler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetBuildCompilerVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetBuildNode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetBuildDir());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetFlagsDebug());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetFlagsOpt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TSystem*) G__getstructoffset())->GetIncludePath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetLinkedLibs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetLinkdefSuffix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSystem*) G__getstructoffset())->GetAclicMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetMakeExe());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetMakeSharedLib());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetSoExt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSystem*) G__getstructoffset())->GetObjExt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TSystem*) G__getstructoffset())->SetBuildDir((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TSystem*) G__getstructoffset())->SetBuildDir((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetFlagsDebug((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetFlagsOpt((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetIncludePath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetMakeExe((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetAclicMode((TSystem::EAclicMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetMakeSharedLib((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetLinkedLibs((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetLinkdefSuffix((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetSoExt((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->SetObjExt((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TSystem*) G__getstructoffset())->SplitAclicMode((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, *(TString*) libp->para[3].ref);
         pobj = new TString(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__Base2_242_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->CleanCompiledMacros();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSystem::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystem::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSystem::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSystem::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSystem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystem::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystem::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSystem::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_242_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSystem::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSystem G__TTSystem;
static int G__G__Base2_242_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSystem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSystem*) (soff+(sizeof(TSystem)*i)))->~G__TTSystem();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSystem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSystem*) (soff))->~G__TTSystem();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<TString,allocator<TString> > */
static int G__G__Base2_253_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->at((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::iterator* pobj;
         vector<TString,allocator<TString> >::iterator xobj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->begin();
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_253_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::iterator* pobj;
         vector<TString,allocator<TString> >::iterator xobj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->end();
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_253_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::reverse_iterator* pobj;
         vector<TString,allocator<TString> >::reverse_iterator xobj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->rbegin();
         pobj = new vector<TString,allocator<TString> >::reverse_iterator(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__Base2_253_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::reverse_iterator* pobj;
         vector<TString,allocator<TString> >::reverse_iterator xobj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->rend();
         pobj = new vector<TString,allocator<TString> >::reverse_iterator(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__Base2_253_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<TString,allocator<TString> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<TString,allocator<TString> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->resize((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->resize((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]), *((TString*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<TString,allocator<TString> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<TString,allocator<TString> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->operator[]((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TString,allocator<TString> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TString,allocator<TString> >[n];
     } else {
       p = new((void*) gvp) vector<TString,allocator<TString> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TString,allocator<TString> >;
     } else {
       p = new((void*) gvp) vector<TString,allocator<TString> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TString,allocator<TString> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TString,allocator<TString> >((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<TString,allocator<TString> >((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TString,allocator<TString> >((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<TString,allocator<TString> >((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TString,allocator<TString> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<TString,allocator<TString> >(*(vector<TString,allocator<TString> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<TString,allocator<TString> >(*(vector<TString,allocator<TString> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TString,allocator<TString> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<TString,allocator<TString> >(*((vector<TString,allocator<TString> >::const_iterator*) G__int(libp->para[0])), *((vector<TString,allocator<TString> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<TString,allocator<TString> >(*((vector<TString,allocator<TString> >::const_iterator*) G__int(libp->para[0])), *((vector<TString,allocator<TString> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >& obj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->operator=(*(vector<TString,allocator<TString> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->reserve((vector<TString,allocator<TString> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->push_back(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->swap(*(vector<TString,allocator<TString> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::iterator* pobj;
         vector<TString,allocator<TString> >::iterator xobj = ((vector<TString,allocator<TString> >*) G__getstructoffset())->insert(*((vector<TString,allocator<TString> >::iterator*) G__int(libp->para[0])), *(TString*) libp->para[1].ref);
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_253_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->insert(*((vector<TString,allocator<TString> >::iterator*) G__int(libp->para[0])), *((vector<TString,allocator<TString> >::const_iterator*) G__int(libp->para[1]))
, *((vector<TString,allocator<TString> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->insert(*((vector<TString,allocator<TString> >::iterator*) G__int(libp->para[0])), (vector<TString,allocator<TString> >::size_type) G__int(libp->para[1])
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->erase(*((vector<TString,allocator<TString> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->erase(*((vector<TString,allocator<TString> >::iterator*) G__int(libp->para[0])), *((vector<TString,allocator<TString> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_253_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TString,allocator<TString> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<TString,allocator<TString> > G__TvectorlETStringcOallocatorlETStringgRsPgR;
static int G__G__Base2_253_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (vector<TString,allocator<TString> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<TString,allocator<TString> >*) (soff+(sizeof(vector<TString,allocator<TString> >)*i)))->~G__TvectorlETStringcOallocatorlETStringgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<TString,allocator<TString> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<TString,allocator<TString> >*) (soff))->~G__TvectorlETStringcOallocatorlETStringgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<TString,allocator<TString> >::iterator */
static int G__G__Base2_254_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TString,allocator<TString> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TString,allocator<TString> >::iterator[n];
     } else {
       p = new((void*) gvp) vector<TString,allocator<TString> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TString,allocator<TString> >::iterator;
     } else {
       p = new((void*) gvp) vector<TString,allocator<TString> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TString,allocator<TString> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<TString,allocator<TString> >::iterator(libp->para[0].ref ? *(const vector<TString,allocator<TString> >::iterator::pointer*) libp->para[0].ref : *(const vector<TString,allocator<TString> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   } else {
     p = new((void*) gvp) vector<TString,allocator<TString> >::iterator(libp->para[0].ref ? *(const vector<TString,allocator<TString> >::iterator::pointer*) libp->para[0].ref : *(const vector<TString,allocator<TString> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator::reference obj = ((const vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator& obj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::iterator* pobj;
         vector<TString,allocator<TString> >::iterator xobj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_254_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator& obj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::iterator* pobj;
         vector<TString,allocator<TString> >::iterator xobj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_254_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator::reference obj = ((const vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator[](*(vector<TString,allocator<TString> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator& obj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator+=(*(vector<TString,allocator<TString> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator* pobj;
         const vector<TString,allocator<TString> >::iterator xobj = ((const vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator+(*(vector<TString,allocator<TString> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_254_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator& obj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator-=(*(vector<TString,allocator<TString> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator* pobj;
         const vector<TString,allocator<TString> >::iterator xobj = ((const vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator-(*(vector<TString,allocator<TString> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator::pointer& obj = ((const vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->base();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TString,allocator<TString> >::iterator* pobj;
         vector<TString,allocator<TString> >::iterator xobj = ((vector<TString,allocator<TString> >::iterator*) G__getstructoffset())->operator=(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref);
         pobj = new vector<TString,allocator<TString> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_254_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   vector<TString,allocator<TString> >::iterator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new vector<TString,allocator<TString> >::iterator(*(vector<TString,allocator<TString> >::iterator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<TString,allocator<TString> >::iterator G__TvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator;
static int G__G__Base2_254_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (vector<TString,allocator<TString> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<TString,allocator<TString> >::iterator*) (soff+(sizeof(vector<TString,allocator<TString> >::iterator)*i)))->~G__TvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<TString,allocator<TString> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<TString,allocator<TString> >::iterator*) (soff))->~G__TvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* reverse_iterator<vector<TString,allocator<TString> >::iterator> */
static int G__G__Base2_255_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   reverse_iterator<vector<TString,allocator<TString> >::iterator>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new reverse_iterator<vector<TString,allocator<TString> >::iterator>[n];
     } else {
       p = new((void*) gvp) reverse_iterator<vector<TString,allocator<TString> >::iterator>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new reverse_iterator<vector<TString,allocator<TString> >::iterator>;
     } else {
       p = new((void*) gvp) reverse_iterator<vector<TString,allocator<TString> >::iterator>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator* pobj;
         const vector<TString,allocator<TString> >::iterator xobj = ((const reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->base();
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2_255_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>::reference obj = ((const reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>& obj = ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         reverse_iterator<vector<TString,allocator<TString> >::iterator>* pobj;
         reverse_iterator<vector<TString,allocator<TString> >::iterator> xobj = ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<TString,allocator<TString> >::iterator>(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__Base2_255_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>& obj = ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         reverse_iterator<vector<TString,allocator<TString> >::iterator>* pobj;
         reverse_iterator<vector<TString,allocator<TString> >::iterator> xobj = ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<TString,allocator<TString> >::iterator>(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__Base2_255_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>* pobj;
         const reverse_iterator<vector<TString,allocator<TString> >::iterator> xobj = ((const reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator+((reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<TString,allocator<TString> >::iterator>(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__Base2_255_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>& obj = ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator+=((reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>* pobj;
         const reverse_iterator<vector<TString,allocator<TString> >::iterator> xobj = ((const reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator-((reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<TString,allocator<TString> >::iterator>(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__Base2_255_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>& obj = ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator-=((reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_255_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<TString,allocator<TString> >::iterator>::reference obj = ((const reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset())->operator[]((reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_255_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   reverse_iterator<vector<TString,allocator<TString> >::iterator>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new reverse_iterator<vector<TString,allocator<TString> >::iterator>(*(reverse_iterator<vector<TString,allocator<TString> >::iterator>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef reverse_iterator<vector<TString,allocator<TString> >::iterator> G__Treverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR;
static int G__G__Base2_255_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (reverse_iterator<vector<TString,allocator<TString> >::iterator>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) (soff+(sizeof(reverse_iterator<vector<TString,allocator<TString> >::iterator>)*i)))->~G__Treverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (reverse_iterator<vector<TString,allocator<TString> >::iterator>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((reverse_iterator<vector<TString,allocator<TString> >::iterator>*) (soff))->~G__Treverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_255_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   reverse_iterator<vector<TString,allocator<TString> >::iterator>* dest = (reverse_iterator<vector<TString,allocator<TString> >::iterator>*) G__getstructoffset();
   const reverse_iterator<vector<TString,allocator<TString> >::iterator>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSysEvtHandler */
static int G__G__Base2_256_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Activate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->DeActivate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TSysEvtHandler*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Add();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Remove();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Activated();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->DeActivated();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Notified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Added();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->Removed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSysEvtHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSysEvtHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSysEvtHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSysEvtHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSysEvtHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSysEvtHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSysEvtHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSysEvtHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_256_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSysEvtHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSysEvtHandler G__TTSysEvtHandler;
static int G__G__Base2_256_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSysEvtHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSysEvtHandler*) (soff+(sizeof(TSysEvtHandler)*i)))->~G__TTSysEvtHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSysEvtHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSysEvtHandler*) (soff))->~G__TTSysEvtHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TStdExceptionHandler */
static int G__G__Base2_261_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TStdExceptionHandler*) G__getstructoffset())->Handle(*(exception*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TStdExceptionHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStdExceptionHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TStdExceptionHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TStdExceptionHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TStdExceptionHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStdExceptionHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStdExceptionHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TStdExceptionHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_261_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TStdExceptionHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TStdExceptionHandler G__TTStdExceptionHandler;
static int G__G__Base2_261_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TStdExceptionHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TStdExceptionHandler*) (soff+(sizeof(TStdExceptionHandler)*i)))->~G__TTStdExceptionHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TStdExceptionHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TStdExceptionHandler*) (soff))->~G__TTStdExceptionHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTime */
static int G__G__Base2_263_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTime[n];
     } else {
       p = new((void*) gvp) TTime[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTime;
     } else {
       p = new((void*) gvp) TTime;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTime((Long64_t) G__Longlong(libp->para[0]));
   } else {
     p = new((void*) gvp) TTime((Long64_t) G__Longlong(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTime(*(TTime*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TTime(*(TTime*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTime& obj = ((TTime*) G__getstructoffset())->operator=(*(TTime*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = ((TTime*) G__getstructoffset())->operator+=(*(TTime*) libp->para[0].ref);
         pobj = new TTime(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__Base2_263_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = ((TTime*) G__getstructoffset())->operator-=(*(TTime*) libp->para[0].ref);
         pobj = new TTime(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__Base2_263_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = ((TTime*) G__getstructoffset())->operator*=(*(TTime*) libp->para[0].ref);
         pobj = new TTime(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__Base2_263_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = ((TTime*) G__getstructoffset())->operator/=(*(TTime*) libp->para[0].ref);
         pobj = new TTime(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__Base2_263_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TTime*) G__getstructoffset())->operator long());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TTime*) G__getstructoffset())->operator unsigned long());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTime*) G__getstructoffset())->operator long long());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) ((const TTime*) G__getstructoffset())->operator unsigned long long());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTime*) G__getstructoffset())->AsString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTime::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTime::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTime::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTime::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTime*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTime*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTime*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTime*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTime::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTime::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTime::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_263_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTime::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTime G__TTTime;
static int G__G__Base2_263_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (TTime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTime*) (soff+(sizeof(TTime)*i)))->~G__TTTime();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTime*) (soff))->~G__TTTime();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* FileStat_t */
static int G__G__Base2_272_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   FileStat_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new FileStat_t[n];
     } else {
       p = new((void*) gvp) FileStat_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new FileStat_t;
     } else {
       p = new((void*) gvp) FileStat_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_FileStat_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_272_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   FileStat_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new FileStat_t(*(FileStat_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_FileStat_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef FileStat_t G__TFileStat_t;
static int G__G__Base2_272_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (FileStat_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((FileStat_t*) (soff+(sizeof(FileStat_t)*i)))->~G__TFileStat_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (FileStat_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((FileStat_t*) (soff))->~G__TFileStat_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_272_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   FileStat_t* dest = (FileStat_t*) G__getstructoffset();
   *dest = *(FileStat_t*) libp->para[0].ref;
   const FileStat_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* UserGroup_t */
static int G__G__Base2_273_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   UserGroup_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new UserGroup_t[n];
     } else {
       p = new((void*) gvp) UserGroup_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new UserGroup_t;
     } else {
       p = new((void*) gvp) UserGroup_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_273_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   UserGroup_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new UserGroup_t(*(UserGroup_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef UserGroup_t G__TUserGroup_t;
static int G__G__Base2_273_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (UserGroup_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((UserGroup_t*) (soff+(sizeof(UserGroup_t)*i)))->~G__TUserGroup_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (UserGroup_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((UserGroup_t*) (soff))->~G__TUserGroup_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_273_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   UserGroup_t* dest = (UserGroup_t*) G__getstructoffset();
   *dest = *(UserGroup_t*) libp->para[0].ref;
   const UserGroup_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* SysInfo_t */
static int G__G__Base2_274_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   SysInfo_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new SysInfo_t[n];
     } else {
       p = new((void*) gvp) SysInfo_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new SysInfo_t;
     } else {
       p = new((void*) gvp) SysInfo_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) SysInfo_t::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SysInfo_t::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) SysInfo_t::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      SysInfo_t::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const SysInfo_t*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((SysInfo_t*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((SysInfo_t*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((SysInfo_t*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SysInfo_t::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) SysInfo_t::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SysInfo_t::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_274_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) SysInfo_t::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_274_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   SysInfo_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new SysInfo_t(*(SysInfo_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef SysInfo_t G__TSysInfo_t;
static int G__G__Base2_274_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (SysInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((SysInfo_t*) (soff+(sizeof(SysInfo_t)*i)))->~G__TSysInfo_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (SysInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((SysInfo_t*) (soff))->~G__TSysInfo_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_274_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   SysInfo_t* dest = (SysInfo_t*) G__getstructoffset();
   *dest = *(SysInfo_t*) libp->para[0].ref;
   const SysInfo_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* CpuInfo_t */
static int G__G__Base2_275_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   CpuInfo_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new CpuInfo_t[n];
     } else {
       p = new((void*) gvp) CpuInfo_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new CpuInfo_t;
     } else {
       p = new((void*) gvp) CpuInfo_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) CpuInfo_t::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) CpuInfo_t::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) CpuInfo_t::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      CpuInfo_t::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const CpuInfo_t*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((CpuInfo_t*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((CpuInfo_t*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((CpuInfo_t*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) CpuInfo_t::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) CpuInfo_t::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) CpuInfo_t::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_275_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) CpuInfo_t::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_275_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   CpuInfo_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new CpuInfo_t(*(CpuInfo_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef CpuInfo_t G__TCpuInfo_t;
static int G__G__Base2_275_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (CpuInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((CpuInfo_t*) (soff+(sizeof(CpuInfo_t)*i)))->~G__TCpuInfo_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (CpuInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((CpuInfo_t*) (soff))->~G__TCpuInfo_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_275_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   CpuInfo_t* dest = (CpuInfo_t*) G__getstructoffset();
   *dest = *(CpuInfo_t*) libp->para[0].ref;
   const CpuInfo_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* MemInfo_t */
static int G__G__Base2_276_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MemInfo_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MemInfo_t[n];
     } else {
       p = new((void*) gvp) MemInfo_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MemInfo_t;
     } else {
       p = new((void*) gvp) MemInfo_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) MemInfo_t::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) MemInfo_t::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) MemInfo_t::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      MemInfo_t::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const MemInfo_t*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((MemInfo_t*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((MemInfo_t*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((MemInfo_t*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) MemInfo_t::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) MemInfo_t::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) MemInfo_t::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_276_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) MemInfo_t::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_276_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   MemInfo_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new MemInfo_t(*(MemInfo_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef MemInfo_t G__TMemInfo_t;
static int G__G__Base2_276_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (MemInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((MemInfo_t*) (soff+(sizeof(MemInfo_t)*i)))->~G__TMemInfo_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (MemInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((MemInfo_t*) (soff))->~G__TMemInfo_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_276_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MemInfo_t* dest = (MemInfo_t*) G__getstructoffset();
   *dest = *(MemInfo_t*) libp->para[0].ref;
   const MemInfo_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ProcInfo_t */
static int G__G__Base2_277_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ProcInfo_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ProcInfo_t[n];
     } else {
       p = new((void*) gvp) ProcInfo_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ProcInfo_t;
     } else {
       p = new((void*) gvp) ProcInfo_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ProcInfo_t::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ProcInfo_t::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ProcInfo_t::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ProcInfo_t::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const ProcInfo_t*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ProcInfo_t*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ProcInfo_t*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ProcInfo_t*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ProcInfo_t::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ProcInfo_t::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ProcInfo_t::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_277_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ProcInfo_t::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_277_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ProcInfo_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ProcInfo_t(*(ProcInfo_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ProcInfo_t G__TProcInfo_t;
static int G__G__Base2_277_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (ProcInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ProcInfo_t*) (soff+(sizeof(ProcInfo_t)*i)))->~G__TProcInfo_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ProcInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ProcInfo_t*) (soff))->~G__TProcInfo_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_277_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ProcInfo_t* dest = (ProcInfo_t*) G__getstructoffset();
   *dest = *(ProcInfo_t*) libp->para[0].ref;
   const ProcInfo_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RedirectHandle_t */
static int G__G__Base2_278_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RedirectHandle_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RedirectHandle_t((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RedirectHandle_t((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RedirectHandle_t[n];
       } else {
         p = new((void*) gvp) RedirectHandle_t[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RedirectHandle_t;
       } else {
         p = new((void*) gvp) RedirectHandle_t;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_278_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RedirectHandle_t*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_278_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RedirectHandle_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RedirectHandle_t(*(RedirectHandle_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RedirectHandle_t G__TRedirectHandle_t;
static int G__G__Base2_278_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (RedirectHandle_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RedirectHandle_t*) (soff+(sizeof(RedirectHandle_t)*i)))->~G__TRedirectHandle_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RedirectHandle_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RedirectHandle_t*) (soff))->~G__TRedirectHandle_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_278_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RedirectHandle_t* dest = (RedirectHandle_t*) G__getstructoffset();
   *dest = *(RedirectHandle_t*) libp->para[0].ref;
   const RedirectHandle_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TProcessEventTimer */
static int G__G__Base2_279_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProcessEventTimer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TProcessEventTimer((Long_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TProcessEventTimer((Long_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TProcessEventTimer*) G__getstructoffset())->ProcessEvents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProcessEventTimer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessEventTimer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TProcessEventTimer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProcessEventTimer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProcessEventTimer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessEventTimer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProcessEventTimer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProcessEventTimer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_279_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProcessEventTimer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TProcessEventTimer G__TTProcessEventTimer;
static int G__G__Base2_279_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TProcessEventTimer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TProcessEventTimer*) (soff+(sizeof(TProcessEventTimer)*i)))->~G__TTProcessEventTimer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TProcessEventTimer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TProcessEventTimer*) (soff))->~G__TTProcessEventTimer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRemoteObject */
static int G__G__Base2_282_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRemoteObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRemoteObject[n];
     } else {
       p = new((void*) gvp) TRemoteObject[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRemoteObject;
     } else {
       p = new((void*) gvp) TRemoteObject;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRemoteObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRemoteObject(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TRemoteObject(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TRemoteObject*) G__getstructoffset())->Browse());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TRemoteObject*) G__getstructoffset())->GetFileStat((FileStat_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TRemoteObject*) G__getstructoffset())->GetClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TRemoteObject*) G__getstructoffset())->GetKeyObjectName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TRemoteObject*) G__getstructoffset())->GetKeyClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRemoteObject*) G__getstructoffset())->SetFolder((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRemoteObject*) G__getstructoffset())->SetKeyObjectName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRemoteObject*) G__getstructoffset())->SetKeyClassName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRemoteObject*) G__getstructoffset())->SetRemoteAddress((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRemoteObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRemoteObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRemoteObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRemoteObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRemoteObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRemoteObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRemoteObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRemoteObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_282_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRemoteObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_282_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TRemoteObject* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TRemoteObject(*(TRemoteObject*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRemoteObject G__TTRemoteObject;
static int G__G__Base2_282_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRemoteObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRemoteObject*) (soff+(sizeof(TRemoteObject)*i)))->~G__TTRemoteObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRemoteObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRemoteObject*) (soff))->~G__TTRemoteObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_282_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRemoteObject* dest = (TRemoteObject*) G__getstructoffset();
   *dest = *(TRemoteObject*) libp->para[0].ref;
   const TRemoteObject& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TROOT */
static int G__G__Base2_288_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->AddClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->AddClassGenerator((TClassGenerator*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TROOT*) G__getstructoffset())->ClassSaved((TClass*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->FindSpecialObject((const char*) G__int(libp->para[0]), libp->para[1].ref ? *(void**) libp->para[1].ref : *(void**) (void*) (&G__Mlong(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->FindObjectClassName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->FindObjectPathName((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->FindSTLClass((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->FindSTLClass((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->ForceStyle((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->ForceStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->FromPopUp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetPluginManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetApplication());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetInterpreter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClass((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClass((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClass((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClass(*(type_info*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClass(*(type_info*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClass(*(type_info*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetColor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->GetConfigOptions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->GetConfigFeatures());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->GetCutClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->GetDefCanvasName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->GetEditHistograms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetEditorMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->GetForceStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetBuiltDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetBuiltTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetSvnRevision());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->GetSvnBranch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TROOT*) G__getstructoffset())->GetSvnDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetVersionDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetVersionTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetVersionInt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetVersionCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TROOT*) G__getstructoffset())->GetVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfClasses());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfColors());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetListOfTypes((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetListOfTypes());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetListOfGlobals((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetListOfGlobals());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetListOfGlobalFunctions((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetListOfGlobalFunctions());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfFiles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfMappedFiles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfSockets());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfCanvases());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfStyles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfGeometries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfBrowsers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfSpecials());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfTasks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfCleanups());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfStreamerInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfMessageHandlers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfClassGenerators());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfSecContexts());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfProofs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetClipboard());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfDataSets());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetListOfBrowsables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetType((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetType((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetStyle((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetFunction((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetGlobal((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetGlobal((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetGlobal((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetGlobal((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetGlobalFunction((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetGlobalFunction((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetGlobalFunction((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetGlobalFunctionWithPrototype((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetGlobalFunctionWithPrototype((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TROOT*) G__getstructoffset())->GetGlobalFunctionWithPrototype((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetGeometry((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetSelectedPrimitive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetSelectedPad());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetNclasses());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->GetNtypes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetRootFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->GetUUIDs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TROOT*) G__getstructoffset())->Idle((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TROOT*) G__getstructoffset())->Idle((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TROOT*) G__getstructoffset())->IgnoreInclude((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->IsBatch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->IsExecutingMacro());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->IsInterrupted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->IsEscaped());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->IsLineProcessing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->IsProofServ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TROOT*) G__getstructoffset())->LoadClass((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TROOT*) G__getstructoffset())->LoadClass((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->LoadClass((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->LoadClass((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TROOT*) G__getstructoffset())->LoadMacro((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TROOT*) G__getstructoffset())->LoadMacro((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TROOT*) G__getstructoffset())->LoadMacro((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->Macro((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->Macro((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->Macro((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TROOT*) G__getstructoffset())->MakeDefCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->Message((Int_t) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->MustClean());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->ProcessLine((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->ProcessLineSync((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->ProcessLineSync((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->ProcessLineFast((const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 108, (long) ((TROOT*) G__getstructoffset())->ProcessLineFast((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TROOT*) G__getstructoffset())->ReadingObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->RefreshBrowsers();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->RemoveClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->Reset((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->Reset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->SaveContext();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->SetApplication((TApplication*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetBatch((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetBatch();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetCutClassName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetCutClassName();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetDefCanvasName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetDefCanvasName();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetEditHistograms((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetEditHistograms();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetEditorMode((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetEditorMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetExecutingMacro((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetExecutingMacro();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetFromPopUp((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetFromPopUp();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetInterrupt((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetInterrupt();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetEscape((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetEscape();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->SetLineIsProcessing();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->SetLineHasBeenProcessed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetReadingObject((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetReadingObject();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetMustClean((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetMustClean();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->SetSelectedPrimitive((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->SetSelectedPad((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->SetStyle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->SetStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TROOT*) G__getstructoffset())->Time((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TROOT*) G__getstructoffset())->Time();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TROOT*) G__getstructoffset())->Timer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::DecreaseDirLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::GetDirLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TROOT::GetMacroPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TROOT::SetMacroPath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::IncreaseDirLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TROOT::IndentLevel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TROOT::Initialized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TROOT::MemCheck());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TROOT::SetDirLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TROOT::SetDirLevel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::ConvertVersionCode2Int((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::ConvertVersionInt2Code((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::RootVersionCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TROOT::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TROOT::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TROOT::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TROOT::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TROOT*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TROOT::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TROOT::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_288_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TROOT::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TROOT G__TTROOT;
static int G__G__Base2_288_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TROOT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TROOT*) (soff+(sizeof(TROOT)*i)))->~G__TTROOT();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TROOT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TROOT*) (soff))->~G__TTROOT();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTask */
static int G__G__Base2_291_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTask* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTask[n];
     } else {
       p = new((void*) gvp) TTask[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTask;
     } else {
       p = new((void*) gvp) TTask;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTask));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTask* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTask((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TTask((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTask));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTask* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTask(*(TTask*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TTask(*(TTask*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_TTask));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TTask& obj = ((TTask*) G__getstructoffset())->operator=(*(TTask*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->Abort();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->Add((TTask*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->CleanTasks();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->Continue();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->Exec((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTask*) G__getstructoffset())->ExecuteTask((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTask*) G__getstructoffset())->ExecuteTask();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->ExecuteTasks((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTask*) G__getstructoffset())->GetBreakin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTask*) G__getstructoffset())->GetBreakout());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTask*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTask*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTask*) G__getstructoffset())->SetActive();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTask*) G__getstructoffset())->SetBreakin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTask*) G__getstructoffset())->SetBreakin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTask*) G__getstructoffset())->SetBreakout((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTask*) G__getstructoffset())->SetBreakout();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTask*) G__getstructoffset())->GetListOfTasks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTask::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTask::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTask::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTask::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTask*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTask::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTask::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTask::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_291_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTask::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTask G__TTTask;
static int G__G__Base2_291_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTask*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTask*) (soff+(sizeof(TTask)*i)))->~G__TTTask();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTask*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTask*) (soff))->~G__TTTask();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<string,allocator<string> > */
static int G__G__Base2_344_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((vector<string,allocator<string> >*) G__getstructoffset())->at((vector<string,allocator<string> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::iterator* pobj;
         vector<string,allocator<string> >::iterator xobj = ((vector<string,allocator<string> >*) G__getstructoffset())->begin();
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_344_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::iterator* pobj;
         vector<string,allocator<string> >::iterator xobj = ((vector<string,allocator<string> >*) G__getstructoffset())->end();
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_344_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::reverse_iterator* pobj;
         vector<string,allocator<string> >::reverse_iterator xobj = ((vector<string,allocator<string> >*) G__getstructoffset())->rbegin();
         pobj = new vector<string,allocator<string> >::reverse_iterator(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__Base2_344_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::reverse_iterator* pobj;
         vector<string,allocator<string> >::reverse_iterator xobj = ((vector<string,allocator<string> >*) G__getstructoffset())->rend();
         pobj = new vector<string,allocator<string> >::reverse_iterator(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__Base2_344_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<string,allocator<string> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<string,allocator<string> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->resize((vector<string,allocator<string> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->resize((vector<string,allocator<string> >::size_type) G__int(libp->para[0]), *((string*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<string,allocator<string> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<string,allocator<string> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((vector<string,allocator<string> >*) G__getstructoffset())->operator[]((vector<string,allocator<string> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<string,allocator<string> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<string,allocator<string> >[n];
     } else {
       p = new((void*) gvp) vector<string,allocator<string> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<string,allocator<string> >;
     } else {
       p = new((void*) gvp) vector<string,allocator<string> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<string,allocator<string> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<string,allocator<string> >((vector<string,allocator<string> >::size_type) G__int(libp->para[0]), *(string*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<string,allocator<string> >((vector<string,allocator<string> >::size_type) G__int(libp->para[0]), *(string*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<string,allocator<string> >((vector<string,allocator<string> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<string,allocator<string> >((vector<string,allocator<string> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<string,allocator<string> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<string,allocator<string> >(*(vector<string,allocator<string> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<string,allocator<string> >(*(vector<string,allocator<string> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<string,allocator<string> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<string,allocator<string> >(*((vector<string,allocator<string> >::const_iterator*) G__int(libp->para[0])), *((vector<string,allocator<string> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<string,allocator<string> >(*((vector<string,allocator<string> >::const_iterator*) G__int(libp->para[0])), *((vector<string,allocator<string> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >& obj = ((vector<string,allocator<string> >*) G__getstructoffset())->operator=(*(vector<string,allocator<string> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->reserve((vector<string,allocator<string> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((vector<string,allocator<string> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((vector<string,allocator<string> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->push_back(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->swap(*(vector<string,allocator<string> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::iterator* pobj;
         vector<string,allocator<string> >::iterator xobj = ((vector<string,allocator<string> >*) G__getstructoffset())->insert(*((vector<string,allocator<string> >::iterator*) G__int(libp->para[0])), *(string*) libp->para[1].ref);
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_344_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->insert(*((vector<string,allocator<string> >::iterator*) G__int(libp->para[0])), *((vector<string,allocator<string> >::const_iterator*) G__int(libp->para[1]))
, *((vector<string,allocator<string> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->insert(*((vector<string,allocator<string> >::iterator*) G__int(libp->para[0])), (vector<string,allocator<string> >::size_type) G__int(libp->para[1])
, *(string*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->erase(*((vector<string,allocator<string> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->erase(*((vector<string,allocator<string> >::iterator*) G__int(libp->para[0])), *((vector<string,allocator<string> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_344_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<string,allocator<string> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<string,allocator<string> > G__TvectorlEstringcOallocatorlEstringgRsPgR;
static int G__G__Base2_344_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (vector<string,allocator<string> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<string,allocator<string> >*) (soff+(sizeof(vector<string,allocator<string> >)*i)))->~G__TvectorlEstringcOallocatorlEstringgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<string,allocator<string> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<string,allocator<string> >*) (soff))->~G__TvectorlEstringcOallocatorlEstringgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<string,allocator<string> >::iterator */
static int G__G__Base2_345_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<string,allocator<string> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<string,allocator<string> >::iterator[n];
     } else {
       p = new((void*) gvp) vector<string,allocator<string> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<string,allocator<string> >::iterator;
     } else {
       p = new((void*) gvp) vector<string,allocator<string> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<string,allocator<string> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<string,allocator<string> >::iterator(libp->para[0].ref ? *(const vector<string,allocator<string> >::iterator::pointer*) libp->para[0].ref : *(const vector<string,allocator<string> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   } else {
     p = new((void*) gvp) vector<string,allocator<string> >::iterator(libp->para[0].ref ? *(const vector<string,allocator<string> >::iterator::pointer*) libp->para[0].ref : *(const vector<string,allocator<string> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator::reference obj = ((const vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator& obj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::iterator* pobj;
         vector<string,allocator<string> >::iterator xobj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_345_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator& obj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::iterator* pobj;
         vector<string,allocator<string> >::iterator xobj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_345_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator::reference obj = ((const vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator[](*(vector<string,allocator<string> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator& obj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator+=(*(vector<string,allocator<string> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator* pobj;
         const vector<string,allocator<string> >::iterator xobj = ((const vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator+(*(vector<string,allocator<string> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_345_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator& obj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator-=(*(vector<string,allocator<string> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator* pobj;
         const vector<string,allocator<string> >::iterator xobj = ((const vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator-(*(vector<string,allocator<string> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_345_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator::pointer& obj = ((const vector<string,allocator<string> >::iterator*) G__getstructoffset())->base();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_345_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<string,allocator<string> >::iterator* pobj;
         vector<string,allocator<string> >::iterator xobj = ((vector<string,allocator<string> >::iterator*) G__getstructoffset())->operator=(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref);
         pobj = new vector<string,allocator<string> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_345_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   vector<string,allocator<string> >::iterator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new vector<string,allocator<string> >::iterator(*(vector<string,allocator<string> >::iterator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<string,allocator<string> >::iterator G__TvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator;
static int G__G__Base2_345_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (vector<string,allocator<string> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<string,allocator<string> >::iterator*) (soff+(sizeof(vector<string,allocator<string> >::iterator)*i)))->~G__TvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<string,allocator<string> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<string,allocator<string> >::iterator*) (soff))->~G__TvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* reverse_iterator<vector<string,allocator<string> >::iterator> */
static int G__G__Base2_346_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   reverse_iterator<vector<string,allocator<string> >::iterator>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new reverse_iterator<vector<string,allocator<string> >::iterator>[n];
     } else {
       p = new((void*) gvp) reverse_iterator<vector<string,allocator<string> >::iterator>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new reverse_iterator<vector<string,allocator<string> >::iterator>;
     } else {
       p = new((void*) gvp) reverse_iterator<vector<string,allocator<string> >::iterator>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator* pobj;
         const vector<string,allocator<string> >::iterator xobj = ((const reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->base();
         pobj = new vector<string,allocator<string> >::iterator(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__Base2_346_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>::reference obj = ((const reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>& obj = ((reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         reverse_iterator<vector<string,allocator<string> >::iterator>* pobj;
         reverse_iterator<vector<string,allocator<string> >::iterator> xobj = ((reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<string,allocator<string> >::iterator>(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__Base2_346_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>& obj = ((reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         reverse_iterator<vector<string,allocator<string> >::iterator>* pobj;
         reverse_iterator<vector<string,allocator<string> >::iterator> xobj = ((reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<string,allocator<string> >::iterator>(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__Base2_346_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>* pobj;
         const reverse_iterator<vector<string,allocator<string> >::iterator> xobj = ((const reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator+((reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<string,allocator<string> >::iterator>(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__Base2_346_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>& obj = ((reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator+=((reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>* pobj;
         const reverse_iterator<vector<string,allocator<string> >::iterator> xobj = ((const reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator-((reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<string,allocator<string> >::iterator>(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__Base2_346_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>& obj = ((reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator-=((reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2_346_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<string,allocator<string> >::iterator>::reference obj = ((const reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset())->operator[]((reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Base2_346_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   reverse_iterator<vector<string,allocator<string> >::iterator>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new reverse_iterator<vector<string,allocator<string> >::iterator>(*(reverse_iterator<vector<string,allocator<string> >::iterator>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef reverse_iterator<vector<string,allocator<string> >::iterator> G__Treverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR;
static int G__G__Base2_346_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) 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 == (char*)G__PVOID) {
       delete[] (reverse_iterator<vector<string,allocator<string> >::iterator>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((reverse_iterator<vector<string,allocator<string> >::iterator>*) (soff+(sizeof(reverse_iterator<vector<string,allocator<string> >::iterator>)*i)))->~G__Treverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (reverse_iterator<vector<string,allocator<string> >::iterator>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((reverse_iterator<vector<string,allocator<string> >::iterator>*) (soff))->~G__Treverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Base2_346_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   reverse_iterator<vector<string,allocator<string> >::iterator>* dest = (reverse_iterator<vector<string,allocator<string> >::iterator>*) G__getstructoffset();
   const reverse_iterator<vector<string,allocator<string> >::iterator>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Base2__0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = operator+(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
         pobj = new string(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__Base2__0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = operator+((char) G__int(libp->para[0]), *(string*) libp->para[1].ref);
         pobj = new string(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__Base2__0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = operator+(*(string*) libp->para[0].ref, (char) G__int(libp->para[1]));
         pobj = new string(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__Base2__0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = operator+(*(string*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         pobj = new string(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__Base2__0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = operator+((const char*) G__int(libp->para[0]), *(string*) libp->para[1].ref);
         pobj = new string(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__Base2__0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      swap(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = operator>>(*(istream*) libp->para[0].ref, *(string*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, *(string*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = getline(*(istream*) libp->para[0].ref, *(string*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = getline(*(istream*) libp->para[0].ref, *(string*) libp->para[1].ref
, (char) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(string::iterator*) libp->para[0].ref, *(string::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(string::iterator*) libp->para[0].ref, *(string::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_339(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ConnectCINT((TQObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_350(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TBuffer& obj = operator>>(*(TBuffer*) libp->para[0].ref, *(TUUID*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_351(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TBuffer& obj = operator<<(*(TBuffer*) libp->para[0].ref, *(TUUID*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_352(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TUUID*) libp->para[0].ref, *(TUUID*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_353(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(TUUID*) libp->para[0].ref, *(TUUID*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_367(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TMD5*) libp->para[0].ref, *(TMD5*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_368(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TBuffer& obj = operator>>(*(TBuffer*) libp->para[0].ref, *(TMD5*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_369(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TBuffer& obj = operator<<(*(TBuffer*) libp->para[0].ref, *(TMD5*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_370(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(TMD5*) libp->para[0].ref, *(TMD5*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_382(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TRef*) libp->para[0].ref, *(TRef*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_383(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(TRef*) libp->para[0].ref, *(TRef*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_454(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_455(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_456(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_457(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_458(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_459(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_460(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) operator-(*(vector<TString,allocator<TString> >::iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_461(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString,allocator<TString> >::iterator* pobj;
         const vector<TString,allocator<TString> >::iterator xobj = operator+((const vector<TString,allocator<TString> >::iterator::difference_type) G__int(libp->para[0]), *(vector<TString,allocator<TString> >::iterator*) libp->para[1].ref);
         pobj = new vector<TString,allocator<TString> >::iterator(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__Base2__0_462(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<TString,allocator<TString> >::reverse_iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::reverse_iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_463(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<TString,allocator<TString> >::reverse_iterator*) libp->para[0].ref, *(vector<TString,allocator<TString> >::reverse_iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_464(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<TString,allocator<TString> >*) libp->para[0].ref, *(vector<TString,allocator<TString> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_465(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<TString,allocator<TString> >*) libp->para[0].ref, *(vector<TString,allocator<TString> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_466(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<TString,allocator<TString> >*) libp->para[0].ref, *(vector<TString,allocator<TString> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_467(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<TString,allocator<TString> >*) libp->para[0].ref, *(vector<TString,allocator<TString> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_468(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<TString,allocator<TString> >*) libp->para[0].ref, *(vector<TString,allocator<TString> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_469(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<TString,allocator<TString> >*) libp->para[0].ref, *(vector<TString,allocator<TString> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_522(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = operator+(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref);
         pobj = new TTime(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__Base2__0_523(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = operator-(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref);
         pobj = new TTime(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__Base2__0_524(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = operator*(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref);
         pobj = new TTime(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__Base2__0_525(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TTime* pobj;
         TTime xobj = operator/(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref);
         pobj = new TTime(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__Base2__0_526(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_527(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_528(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_529(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_530(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_531(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(TTime*) libp->para[0].ref, *(TTime*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_532(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISDIR((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_533(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISCHR((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_534(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISBLK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_535(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISREG((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_536(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISLNK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_537(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISFIFO((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_538(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISSOCK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_539(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) R_ISOFF((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_540(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_541(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_542(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_543(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_544(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_545(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_546(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) operator-(*(vector<string,allocator<string> >::iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_547(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<string,allocator<string> >::iterator* pobj;
         const vector<string,allocator<string> >::iterator xobj = operator+((const vector<string,allocator<string> >::iterator::difference_type) G__int(libp->para[0]), *(vector<string,allocator<string> >::iterator*) libp->para[1].ref);
         pobj = new vector<string,allocator<string> >::iterator(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__Base2__0_548(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<string,allocator<string> >::reverse_iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::reverse_iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_549(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<string,allocator<string> >::reverse_iterator*) libp->para[0].ref, *(vector<string,allocator<string> >::reverse_iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_550(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<string,allocator<string> >*) libp->para[0].ref, *(vector<string,allocator<string> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_551(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<string,allocator<string> >*) libp->para[0].ref, *(vector<string,allocator<string> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_552(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<string,allocator<string> >*) libp->para[0].ref, *(vector<string,allocator<string> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_553(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<string,allocator<string> >*) libp->para[0].ref, *(vector<string,allocator<string> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_554(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<string,allocator<string> >*) libp->para[0].ref, *(vector<string,allocator<string> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Base2__0_555(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<string,allocator<string> >*) libp->para[0].ref, *(vector<string,allocator<string> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TMemberInspector */

/* TObject */

/* TNamed */

/* TString */

/* string */

/* string::iterator */

/* TStorage */

/* TTimer */

/* TProcessID */

/* TRefCnt */

/* TRegexp */

/* TPRegexp */

/* TSubString */

/* TStringRef */

/* TStringLong */

/* TQConnection */

/* TQObject */

/* TQObjSender */

/* TSignalHandler */

/* TStopwatch */

/* TUUID */

/* TExec */

/* TFolder */

/* TObjString */

/* TMD5 */

/* TMacro */

/* TMessageHandler */

/* TPluginManager */

/* TPluginHandler */

/* TPoint */

/* TPMERegexp */

/* TStringToken */

/* TProcessUUID */

/* TQClass */

/* TQCommand */

/* TQUndoManager */

/* TRef */

/* TSystemFile */

/* TSystemDirectory */

/* TSystem */

/* vector<TString,allocator<TString> > */

/* vector<TString,allocator<TString> >::iterator */

/* reverse_iterator<vector<TString,allocator<TString> >::iterator> */

/* TSysEvtHandler */

/* TStdExceptionHandler */

/* TTime */

/* FileStat_t */

/* UserGroup_t */

/* SysInfo_t */

/* CpuInfo_t */

/* MemInfo_t */

/* ProcInfo_t */

/* RedirectHandle_t */

/* TProcessEventTimer */

/* TRemoteObject */

/* TROOT */

/* TTask */

/* vector<string,allocator<string> > */

/* vector<string,allocator<string> >::iterator */

/* reverse_iterator<vector<string,allocator<string> >::iterator> */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Base2 {
 public:
  G__Sizep2memfuncG__Base2(): p(&G__Sizep2memfuncG__Base2::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Base2::*p)();
};

size_t G__get_sizep2memfuncG__Base2()
{
  G__Sizep2memfuncG__Base2 a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__Base2() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TNamed))) {
     TNamed *G__Lderived;
     G__Lderived=(TNamed*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TNamed),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TTimer))) {
     TTimer *G__Lderived;
     G__Lderived=(TTimer*)0x1000;
     {
       TSysEvtHandler *G__Lpbase=(TSysEvtHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TTimer),G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TTimer),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TTimer),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TProcessID))) {
     TProcessID *G__Lderived;
     G__Lderived=(TProcessID*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessID),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessID),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TStringRef))) {
     TStringRef *G__Lderived;
     G__Lderived=(TStringRef*)0x1000;
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringRef),G__get_linked_tagnum(&G__G__Base2LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TStringLong))) {
     TStringLong *G__Lderived;
     G__Lderived=(TStringLong*)0x1000;
     {
       TString *G__Lpbase=(TString*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringLong),G__get_linked_tagnum(&G__G__Base2LN_TString),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TQConnection))) {
     TQConnection *G__Lderived;
     G__Lderived=(TQConnection*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection),G__get_linked_tagnum(&G__G__Base2LN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection),G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection),G__get_linked_tagnum(&G__G__Base2LN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TQObjSender))) {
     TQObjSender *G__Lderived;
     G__Lderived=(TQObjSender*)0x1000;
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQObjSender),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler))) {
     TSignalHandler *G__Lderived;
     G__Lderived=(TSignalHandler*)0x1000;
     {
       TSysEvtHandler *G__Lpbase=(TSysEvtHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler),G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TStopwatch))) {
     TStopwatch *G__Lderived;
     G__Lderived=(TStopwatch*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStopwatch),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TCollection))) {
     TCollection *G__Lderived;
     G__Lderived=(TCollection*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TCollection),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection))) {
     TSeqCollection *G__Lderived;
     G__Lderived=(TSeqCollection*)0x1000;
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),G__get_linked_tagnum(&G__G__Base2LN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TExec))) {
     TExec *G__Lderived;
     G__Lderived=(TExec*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TExec),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TExec),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TFolder))) {
     TFolder *G__Lderived;
     G__Lderived=(TFolder*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TFolder),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TFolder),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TObjString))) {
     TObjString *G__Lderived;
     G__Lderived=(TObjString*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TObjString),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TMacro))) {
     TMacro *G__Lderived;
     G__Lderived=(TMacro*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TMacro),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TMacro),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler))) {
     TMessageHandler *G__Lderived;
     G__Lderived=(TMessageHandler*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TPluginManager))) {
     TPluginManager *G__Lderived;
     G__Lderived=(TPluginManager*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TPluginManager),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler))) {
     TPluginHandler *G__Lderived;
     G__Lderived=(TPluginHandler*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp))) {
     TPMERegexp *G__Lderived;
     G__Lderived=(TPMERegexp*)0x1000;
     {
       TPRegexp *G__Lpbase=(TPRegexp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp),G__get_linked_tagnum(&G__G__Base2LN_TPRegexp),(long)G__Lpbase-(long)G__Lderived,2,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TStringToken))) {
     TStringToken *G__Lderived;
     G__Lderived=(TStringToken*)0x1000;
     {
       TString *G__Lpbase=(TString*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringToken),G__get_linked_tagnum(&G__G__Base2LN_TString),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID))) {
     TProcessUUID *G__Lderived;
     G__Lderived=(TProcessUUID*)0x1000;
     {
       TProcessID *G__Lpbase=(TProcessID*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID),G__get_linked_tagnum(&G__G__Base2LN_TProcessID),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TQClass))) {
     TQClass *G__Lderived;
     G__Lderived=(TQClass*)0x1000;
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TClass *G__Lpbase=(TClass*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass),G__get_linked_tagnum(&G__G__Base2LN_TClass),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TDictionary *G__Lpbase=(TDictionary*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass),G__get_linked_tagnum(&G__G__Base2LN_TDictionary),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TQCommand))) {
     TQCommand *G__Lderived;
     G__Lderived=(TQCommand*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand),G__get_linked_tagnum(&G__G__Base2LN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand),G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand),G__get_linked_tagnum(&G__G__Base2LN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager))) {
     TQUndoManager *G__Lderived;
     G__Lderived=(TQUndoManager*)0x1000;
     {
       TQCommand *G__Lpbase=(TQCommand*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager),G__get_linked_tagnum(&G__G__Base2LN_TQCommand),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager),G__get_linked_tagnum(&G__G__Base2LN_TList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager),G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager),G__get_linked_tagnum(&G__G__Base2LN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TRef))) {
     TRef *G__Lderived;
     G__Lderived=(TRef*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TRef),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TSystemFile))) {
     TSystemFile *G__Lderived;
     G__Lderived=(TSystemFile*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemFile),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemFile),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory))) {
     TSystemDirectory *G__Lderived;
     G__Lderived=(TSystemDirectory*)0x1000;
     {
       TSystemFile *G__Lpbase=(TSystemFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory),G__get_linked_tagnum(&G__G__Base2LN_TSystemFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TSystem))) {
     TSystem *G__Lderived;
     G__Lderived=(TSystem*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystem),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystem),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler))) {
     TSysEvtHandler *G__Lderived;
     G__Lderived=(TSysEvtHandler*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler))) {
     TStdExceptionHandler *G__Lderived;
     G__Lderived=(TStdExceptionHandler*)0x1000;
     {
       TSysEvtHandler *G__Lpbase=(TSysEvtHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler),G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer))) {
     TProcessEventTimer *G__Lderived;
     G__Lderived=(TProcessEventTimer*)0x1000;
     {
       TTimer *G__Lpbase=(TTimer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer),G__get_linked_tagnum(&G__G__Base2LN_TTimer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSysEvtHandler *G__Lpbase=(TSysEvtHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer),G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer),G__get_linked_tagnum(&G__G__Base2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject))) {
     TRemoteObject *G__Lderived;
     G__Lderived=(TRemoteObject*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TROOT))) {
     TROOT *G__Lderived;
     G__Lderived=(TROOT*)0x1000;
     {
       TDirectory *G__Lpbase=(TDirectory*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TROOT),G__get_linked_tagnum(&G__G__Base2LN_TDirectory),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TROOT),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TROOT),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Base2LN_TTask))) {
     TTask *G__Lderived;
     G__Lderived=(TTask*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TTask),G__get_linked_tagnum(&G__G__Base2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Base2LN_TTask),G__get_linked_tagnum(&G__G__Base2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Base2() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   G__search_typename2("UShort_t",114,-1,0,-1);
   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Ssiz_t",105,-1,0,-1);
   G__setnewtype(-1,"String size (int)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("SCoord_t",115,-1,0,-1);
   G__setnewtype(-1,"Screen coordinates (short)",0);
   G__search_typename2("ShowMembersFunc_t",89,-1,0,-1);
   G__setnewtype(-1,"void (*ShowMembersFunc_t)(void *obj, TMemberInspector &R__insp);",0);
   G__search_typename2("value_type",99,-1,0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",67,-1,0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",67,-1,256,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",99,-1,1,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",99,-1,257,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("traits_type",105,-1,0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator),256,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_string));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FreeHookFun_t",89,-1,0,-1);
   G__setnewtype(-1,"void (*FreeHookFun_t)(void*, void *addr, size_t);",0);
   G__search_typename2("ReAllocFun_t",89,-1,0,-1);
   G__setnewtype(-1,"void *(*ReAllocFun_t)(void*, size_t);",0);
   G__search_typename2("ReAllocCFun_t",89,-1,0,-1);
   G__setnewtype(-1,"void *(*ReAllocCFun_t)(void*, size_t, size_t);",0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__Base2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__Base2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__Base2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__G__Base2LN_TString),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Base2LN_TString),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Base2LN_TString),256,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Base2LN_TString),1,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__Base2LN_TString),257,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Base2LN_TString),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Base2LN_TString),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Base2LN_TString),1,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__Base2LN_TString),1,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Base2LN_TString),0,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Base2LN_TString),1,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Func_t",89,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__G__Base2LN_string),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Base2LN_string),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Base2LN_string),256,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Base2LN_string),1,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__Base2LN_string),257,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Base2LN_string),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Base2LN_string),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Base2LN_string),1,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__Base2LN_string),1,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Base2LN_string),0,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Base2LN_string),1,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TMemberInspector */
static void G__setup_memvarTMemberInspector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TMemberInspector));
   { TMemberInspector *p; p=(TMemberInspector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TMemberInspectorcLcLTParentBuf),-1,-1,4,"fParent=",0,"current inspection \"path\"");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObject */
static void G__setup_memvarTObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TObject));
   { TObject *p; p=(TObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fUniqueID=",0,"object unique identifier");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBits=",0,"bit field status word");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgDtorOnly=",0,"object for which to call dtor only (i.e. no delete)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgObjectStat=",0,"if true keep track of objects in TObjectTable");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kCanDelete=%lldLL",(long long)TObject::kCanDelete).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kMustCleanup=%lldLL",(long long)TObject::kMustCleanup).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kObjInCanvas=%lldLL",(long long)TObject::kObjInCanvas).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsReferenced=%lldLL",(long long)TObject::kIsReferenced).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kHasUUID=%lldLL",(long long)TObject::kHasUUID).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kCannotPick=%lldLL",(long long)TObject::kCannotPick).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kNoContextMenu=%lldLL",(long long)TObject::kNoContextMenu).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kInvalidObject=%lldLL",(long long)TObject::kInvalidObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsOnHeap=%lldLL",(long long)TObject::kIsOnHeap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNotDeleted=%lldLL",(long long)TObject::kNotDeleted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kZombie=%lldLL",(long long)TObject::kZombie).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBitMask=%lldLL",(long long)TObject::kBitMask).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kSingleKey=%lldLL",(long long)TObject::kSingleKey).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kOverwrite=%lldLL",(long long)TObject::kOverwrite).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWriteDelete=%lldLL",(long long)TObject::kWriteDelete).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TNamed */
static void G__setup_memvarTNamed(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TNamed));
   { TNamed *p; p=(TNamed*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fName=",0,"object identifier");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fTitle=",0,"object title");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TString */
static void G__setup_memvarTString(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TString));
   { TString *p; p=(TString*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-2,4,"fgInitialCapac=",0,"Initial allocation Capacity");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-2,4,"fgResizeInc=",0,"Resizing increment");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-2,4,"fgFreeboard=",0,"Max empty space before reclaim");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fData=",0,"ref. counted data (TStringRef is in front)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStringcLcLEStripType),-1,-2,1,G__FastAllocString(2048).Format("kLeading=%lldLL",(long long)TString::kLeading).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStringcLcLEStripType),-1,-2,1,G__FastAllocString(2048).Format("kTrailing=%lldLL",(long long)TString::kTrailing).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStringcLcLEStripType),-1,-2,1,G__FastAllocString(2048).Format("kBoth=%lldLL",(long long)TString::kBoth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStringcLcLECaseCompare),-1,-2,1,G__FastAllocString(2048).Format("kExact=%lldLL",(long long)TString::kExact).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStringcLcLECaseCompare),-1,-2,1,G__FastAllocString(2048).Format("kIgnoreCase=%lldLL",(long long)TString::kIgnoreCase).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* string */
static void G__setup_memvarstring(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_string));
   { string *p; p=(string*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,104,0,1,-1,G__defined_typename("size_t"),-2,1,G__FastAllocString(2048).Format("npos=%lluULL",(unsigned long long)string::npos).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* string::iterator */
static void G__setup_memvarstringcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator));
   { string::iterator *p; p=(string::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TStorage */
static void G__setup_memvarTStorage(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TStorage));
   { TStorage *p; p=(TStorage*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-2,4,"fgHeapBegin=",0,"begin address of heap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-2,4,"fgHeapEnd=",0,"end address of heap");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("size_t"),-2,4,"fgMaxBlockSize=",0,"largest block allocated");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("FreeHookFun_t"),-2,4,"fgFreeHook=",0,"function called on free");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-2,4,"fgFreeHookData=",0,"data used by this function");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReAllocFun_t"),-2,4,"fgReAllocHook=",0,"custom ReAlloc");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ReAllocCFun_t"),-2,4,"fgReAllocCHook=",0,"custom ReAlloc with length check");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgHasCustomNewDelete=",0,"true if using ROOT's new/delete");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTimer */
static void G__setup_memvarTTimer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TTimer));
   { TTimer *p; p=(TTimer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TTime),-1,-1,2,"fTime=",0,"time out time in ms");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TTime),-1,-1,2,"fAbsTime=",0,"absolute time out time in ms");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTimeout=",0,"true if timer has timed out");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSync=",0,"true if synchrounous timer");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIntSyscalls=",0,"true is a-synchronous timer is to interrupt system calls");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTimeID=",0,"the system ID of this timer (for WIN32)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TObject),-1,-1,2,"fObject=",0,"object to be notified (if any)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fCommand=",0,"interpreter command to be executed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProcessID */
static void G__setup_memvarTProcessID(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessID));
   { TProcessID *p; p=(TProcessID*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCount=",0,"!Reference count to this object (from TFile)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TObjArray),-1,-1,2,"fObjects=",0,"!Array pointing to the referenced objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TProcessID),-1,-2,2,"fgPID=",0,"Pointer to current session ProcessID");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TObjArray),-1,-2,2,"fgPIDs=",0,"Table of ProcessIDs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TExMap),-1,-2,2,"fgObjPIDs=",0,"Table pointer to pids");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgNumber=",0,"Referenced objects count");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRefCnt */
static void G__setup_memvarTRefCnt(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TRefCnt));
   { TRefCnt *p; p=(TRefCnt*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fRefs=",0,"(1 less than) number of references");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TRefCntcLcLEReferenceFlag),-1,-2,1,G__FastAllocString(2048).Format("kStaticInit=%lldLL",(long long)TRefCnt::kStaticInit).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRegexp */
static void G__setup_memvarTRegexp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TRegexp));
   { TRegexp *p; p=(TRegexp*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TRegexpcLcLEStatVal),-1,-2,1,G__FastAllocString(2048).Format("kOK=%lldLL",(long long)TRegexp::kOK).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TRegexpcLcLEStatVal),-1,-2,1,G__FastAllocString(2048).Format("kIllegal=%lldLL",(long long)TRegexp::kIllegal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TRegexpcLcLEStatVal),-1,-2,1,G__FastAllocString(2048).Format("kNomem=%lldLL",(long long)TRegexp::kNomem).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TRegexpcLcLEStatVal),-1,-2,1,G__FastAllocString(2048).Format("kToolong=%lldLL",(long long)TRegexp::kToolong).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,82,0,0,-1,G__defined_typename("Pattern_t"),-1,4,"fPattern=",0,"Compiled pattern");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base2LN_TRegexpcLcLEStatVal),-1,-1,4,"fStat=",0,"Status");
   G__memvar_setup((void*)G__PVOID,104,0,1,-1,-1,-2,4,"fgMaxpat=0ULL",0,"Max length of compiled pattern");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPRegexp */
static void G__setup_memvarTPRegexp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TPRegexp));
   { TPRegexp *p; p=(TPRegexp*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TPRegexpcLcLdA),-1,-2,2,"kPCRE_GLOBAL=-2147483648LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TPRegexpcLcLdA),-1,-2,2,"kPCRE_OPTIMIZE=1073741824LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TPRegexpcLcLdA),-1,-2,2,"kPCRE_DEBUG_MSGS=536870912LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TPRegexpcLcLdA),-1,-2,2,"kPCRE_INTMASK=4095LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fPattern=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_PCREPriv_t),-1,-1,2,"fPriv=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fPCREOpts=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSubString */
static void G__setup_memvarTSubString(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TSubString));
   { TSubString *p; p=(TSubString*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fStr=",0,"Referenced string");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-1,4,"fBegin=",0,"Index of starting character");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-1,4,"fExtent=",0,"Length of TSubString");
   }
   G__tag_memvar_reset();
}


   /* TStringRef */
static void G__setup_memvarTStringRef(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringRef));
   { TStringRef *p; p=(TStringRef*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-1,4,"fCapacity=",0,"Max string length (excluding null)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Ssiz_t"),-1,4,"fNchars=",0,"String length (excluding null)");
   }
   G__tag_memvar_reset();
}


   /* TStringLong */
static void G__setup_memvarTStringLong(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   { TStringLong *p; p=(TStringLong*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQConnection */
static void G__setup_memvarTQConnection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection));
   { TQConnection *p; p=(TQConnection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TQSlot),-1,-1,2,"fSlot=",0,"slot-method calling interface");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fReceiver=",0,"ptr to object to which slot is applied");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fClassName=",0,"class name of the receiver");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQObject */
static void G__setup_memvarTQObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TQObject));
   { TQObject *p; p=(TQObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fListOfSignals=",0,"! list of signals from this object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fListOfConnections=",0,"! list of connections to this object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSignalsBlocked=",0,"! flag used for suppression of signals");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgAllSignalsBlocked=",0,"flag used for suppression of all signals");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQObjSender */
static void G__setup_memvarTQObjSender(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TQObjSender));
   { TQObjSender *p; p=(TQObjSender*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fSender=",0,"delegation object");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fSenderClass=",0,"class name of delegation object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSignalHandler */
static void G__setup_memvarTSignalHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler));
   { TSignalHandler *p; p=(TSignalHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,2,"fSignal=",0,"Signal to be handled");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSync=",0,"Synchronous or a-synchronous signal");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDelay=",0,"Delay handling of signal (use fDelay in Notify())");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStopwatch */
static void G__setup_memvarTStopwatch(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TStopwatch));
   { TStopwatch *p; p=(TStopwatch*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStopwatchcLcLEState),-1,-2,4,"kUndefined=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStopwatchcLcLEState),-1,-2,4,"kStopped=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStopwatchcLcLEState),-1,-2,4,"kRunning=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStartRealTime=",0,"wall clock start time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStopRealTime=",0,"wall clock stop time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStartCpuTime=",0,"cpu start time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStopCpuTime=",0,"cpu stop time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTotalCpuTime=",0,"total cpu time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTotalRealTime=",0,"total real time");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base2LN_TStopwatchcLcLEState),-1,-1,4,"fState=",0,"stopwatch state");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCounter=",0,"number of times the stopwatch was started");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TUUID */
static void G__setup_memvarTUUID(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TUUID));
   { TUUID *p; p=(TUUID*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fUUIDIndex=",0,"!index in the list of UUIDs in TProcessUUID");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTimeLow=",0,"60 bit time, lower 32 bits");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fTimeMid=",0,"middle 16 time bits");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fTimeHiAndVersion=",0,"high 12 time bits + 4 UUID version bits");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fClockSeqHiAndReserved=",0,"high 6 clock bits + 2 bits reserved");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fClockSeqLow=",0,"low 8 clock bits");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fNode[6]=",0,"6 node id bytes");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TExec */
static void G__setup_memvarTExec(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TExec));
   { TExec *p; p=(TExec*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFolder */
static void G__setup_memvarTFolder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TFolder));
   { TFolder *p; p=(TFolder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fFolders=",0,"pointer to the list of folders");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsOwner=",0,"true if folder own its contained objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObjString */
static void G__setup_memvarTObjString(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TObjString));
   { TObjString *p; p=(TObjString*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fString=",0,"wrapped TString");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMD5 */
static void G__setup_memvarTMD5(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TMD5));
   { TMD5 *p; p=(TMD5*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBuf[4]=",0,"!temp buffer");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBits[2]=",0,"!temp buffer");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fIn[64]=",0,"!temp buffer");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fDigest[16]=",0,"message digest");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFinalized=",0,"true if message digest has been finalized");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMacro */
static void G__setup_memvarTMacro(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TMacro));
   { TMacro *p; p=(TMacro*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fLines=",0,"collection of lines");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fParams=",0,"default string of macro parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMessageHandler */
static void G__setup_memvarTMessageHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler));
   { TMessageHandler *p; p=(TMessageHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-1,2,"fClass=",0,"class for which message has to be handled");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObject),-1,-1,2,"fMessObj=",0,"object generating message");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMessId=",0,"message id (often matching specific enum in fClass)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"number of different messages handled");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCnts=",0,"count per message");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMessIds=",0,"message ids");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDerived=",0,"if true handle messages also for derived classes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPluginManager */
static void G__setup_memvarTPluginManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TPluginManager));
   { TPluginManager *p; p=(TPluginManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,4,"fHandlers=",0,"list of plugin handlers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_THashTable),-1,-1,4,"fBasesLoaded=",0,"! table of base classes already checked or loaded");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReadingDirs=",0,"! true if we are running LoadHandlersFromPluginDirs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPluginHandler */
static void G__setup_memvarTPluginHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler));
   { TPluginHandler *p; p=(TPluginHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fBase=",0,"base class which will be extended by plugin");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fRegexp=",0,"regular expression which must be matched in URI");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fClass=",0,"class to be loaded from plugin library");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fPlugin=",0,"plugin library which should contain fClass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fCtor=",0,"ctor used to instantiate object of fClass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fOrigin=",0,"origin of plugin handler definition");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TMethodCall),-1,-1,4,"fCallEnv=",0,"!ctor method call environment");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFunction),-1,-1,4,"fMethod=",0,"!ctor method or global function");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCanCall=",0,"!if 1 fCallEnv is ok, -1 fCallEnv is not ok");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsMacro=",0,"plugin is a macro and not a library");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsGlobal=",0,"plugin ctor is a global function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPoint */
static void G__setup_memvarTPoint(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TPoint));
   { TPoint *p; p=(TPoint*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),115,0,0,-1,G__defined_typename("SCoord_t"),-1,1,"fX=",0,"X device coordinate");
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),115,0,0,-1,G__defined_typename("SCoord_t"),-1,1,"fY=",0,"Y device coordinate");
   }
   G__tag_memvar_reset();
}


   /* TPMERegexp */
static void G__setup_memvarTPMERegexp(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp));
   { TPMERegexp *p; p=(TPMERegexp*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNMaxMatches=",0,"maximum number of matches");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNMatches=",0,"number of matches returned from last pcre_exec call");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TArrayI),-1,-1,2,"fMarkers=",0,"last set of indexes of matches");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fLastStringMatched=",0,"copy of the last TString matched");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fAddressOfLastString=",0,"used for checking for change of TString in global match");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastGlobalPosition=",0,"end of last match when kPCRE_GLOBAL is set");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStringToken */
static void G__setup_memvarTStringToken(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringToken));
   { TStringToken *p; p=(TStringToken*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fFullStr=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TPRegexp),-1,-1,2,"fSplitRe=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReturnVoid=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProcessUUID */
static void G__setup_memvarTProcessUUID(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID));
   { TProcessUUID *p; p=(TProcessUUID*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fUUIDs=",0,"Global list of TUUIDs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TBits),-1,-1,2,"fActive=",0,"Table of active UUIDs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQClass */
static void G__setup_memvarTQClass(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass));
   { TQClass *p; p=(TQClass*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQCommand */
static void G__setup_memvarTQCommand(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand));
   { TQCommand *p; p=(TQCommand*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TQConnection),-1,-1,2,"fRedo=",0,"do/redo action");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TQConnection),-1,-1,2,"fUndo=",0,"undo action");
   G__memvar_setup((void*)0,76,0,0,-1,G__defined_typename("Long_t"),-1,2,"fRedoArgs=",0,"redo values");
   G__memvar_setup((void*)0,76,0,0,-1,G__defined_typename("Long_t"),-1,2,"fUndoArgs=",0,"undo values");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNRargs=",0,"number of redo arguments");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNUargs=",0,"number of undo arguments");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fState=",0,"-1 undoing on, 1 redoing on, 0 nothing in progress");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatus=",0,"fStatus++ after Redo(), fStatus-- after Undo()");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNewDelete=",0,"kTRUE if Redo/Undo methods are new/delete");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fName=",0,"command name. Default is \"ClassName::RedoName(args)\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fTitle=",0,"command description");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fObject=",0,"object to which undo/redo actions applied");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQUndoManager */
static void G__setup_memvarTQUndoManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager));
   { TQUndoManager *p; p=(TQUndoManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TObjLink),-1,-1,2,"fCursor=",0,"current position in history stack");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TQCommand),-1,-1,2,"fCurrent=",0,"the latest executed command");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLimit=",0,"maximum number of commands can be located in stack");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fLogBook=",0,"listing of all actions during execution");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLogging=",0,"kTRUE if logging is ON");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRef */
static void G__setup_memvarTRef(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TRef));
   { TRef *p; p=(TRef*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TProcessID),-1,-1,2,"fPID=",0,"!Pointer to ProcessID when TRef was written");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TObjArray),-1,-2,2,"fgExecs=",0,"List of execs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TObject),-1,-2,2,"fgObject=",0,"In: this, Out: pointer to object (used by Action on Demand)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TRefcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNotComputed=%lldLL",(long long)TRef::kNotComputed).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSystemFile */
static void G__setup_memvarTSystemFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemFile));
   { TSystemFile *p; p=(TSystemFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,4,"fIconName=",0,"icon name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSystemDirectory */
static void G__setup_memvarTSystemDirectory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory));
   { TSystemDirectory *p; p=(TSystemDirectory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TOrdCollection),-1,-1,2,"fDirsInBrowser=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TOrdCollection),-1,-1,2,"fFilesInBrowser=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSystem */
static void G__setup_memvarTSystem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystem));
   { TSystem *p; p=(TSystem*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TSystemcLcLEAclicMode),-1,-2,1,G__FastAllocString(2048).Format("kDefault=%lldLL",(long long)TSystem::kDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TSystemcLcLEAclicMode),-1,-2,1,G__FastAllocString(2048).Format("kDebug=%lldLL",(long long)TSystem::kDebug).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TSystemcLcLEAclicMode),-1,-2,1,G__FastAllocString(2048).Format("kOpt=%lldLL",(long long)TSystem::kOpt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TSystemcLcLEAclicProperties),-1,-2,1,G__FastAllocString(2048).Format("kFlatBuildDir=%lldLL",(long long)TSystem::kFlatBuildDir).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFdSet),-1,-1,2,"fReadmask=",0,"!Files that should be checked for read events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFdSet),-1,-1,2,"fWritemask=",0,"!Files that should be checked for write events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFdSet),-1,-1,2,"fReadready=",0,"!Files with reads waiting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFdSet),-1,-1,2,"fWriteready=",0,"!Files with writes waiting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFdSet),-1,-1,2,"fSignals=",0,"!Signals that were trapped");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNfd=",0,"Number of fd's in masks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxrfd=",0,"Largest fd in read mask");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxwfd=",0,"Largest fd in write mask");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSigcnt=",0,"Number of pending signals");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fWdpath=",0,"Working directory");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fHostname=",0,"Hostname");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInsideNotify=",0,"Used by DispatchTimers()");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBeepFreq=",0,"Used by Beep()");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBeepDuration=",0,"Used by Beep()");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInControl=",0,"True if in eventloop");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDone=",0,"True if eventloop should be finished");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLevel=",0,"Level of nested eventloops");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fLastErrorString=",0,"Last system error message");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fTimers=",0,"List of timers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fSignalHandler=",0,"List of signal handlers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fFileHandler=",0,"List of file handlers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fStdExceptionHandler=",0,"List of std::exception handlers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fOnExitList=",0,"List of items to be cleaned-up on exit");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fListLibs=",0,"List shared libraries, cache used by GetLibraries");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fBuildArch=",0,"Architecure for which ROOT was built (passed to ./configure)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fBuildCompiler=",0,"Compiler used to build this ROOT");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fBuildCompilerVersion=",0,"Compiler version used to build this ROOT");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fBuildNode=",0,"Detailed information where ROOT was built");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fBuildDir=",0,"Location where to build ACLiC shared library and use as scratch area.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fFlagsDebug=",0,"Flags for debug compilation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fFlagsOpt=",0,"Flags for optimized compilation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fListPaths=",0,"List of all include (fIncludePath + interpreter include path). Cache used by GetIncludePath");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fIncludePath=",0,"Used to expand $IncludePath in the directives given to SetMakeSharedLib and SetMakeExe");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fLinkedLibs=",0,"Used to expand $LinkedLibs in the directives given to SetMakeSharedLib and SetMakeExe");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fSoExt=",0,"Extension of shared library (.so, .sl, .a, .dll, etc.)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fObjExt=",0,"Extension of object files (.o, .obj, etc.)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSystemcLcLEAclicMode),-1,-1,2,"fAclicMode=",0,"Whether the compilation should be done debug or opt");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fMakeSharedLib=",0,"Directive used to build a shared library");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fMakeExe=",0,"Directive used to build an executable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fLinkdefSuffix=",0,"Default suffix for linkdef files to be used by ACLiC (see EACLiCProperties)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fAclicProperties=",0,"Various boolean flag for change ACLiC's behavior.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fCompiled=",0,"List of shared libs from compiled macros to be deleted");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fHelpers=",0,"List of helper classes for alternative file/directory access");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* vector<TString,allocator<TString> > */
static void G__setup_memvarvectorlETStringcOallocatorlETStringgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   { vector<TString,allocator<TString> > *p; p=(vector<TString,allocator<TString> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<TString,allocator<TString> >::iterator */
static void G__setup_memvarvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   { vector<TString,allocator<TString> >::iterator *p; p=(vector<TString,allocator<TString> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* reverse_iterator<vector<TString,allocator<TString> >::iterator> */
static void G__setup_memvarreverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   { reverse_iterator<vector<TString,allocator<TString> >::iterator> *p; p=(reverse_iterator<vector<TString,allocator<TString> >::iterator>*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TSysEvtHandler */
static void G__setup_memvarTSysEvtHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler));
   { TSysEvtHandler *p; p=(TSysEvtHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsActive=",0,"kTRUE if handler is active, kFALSE if not active");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TStdExceptionHandler */
static void G__setup_memvarTStdExceptionHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler));
   { TStdExceptionHandler *p; p=(TStdExceptionHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandlercLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kSEProceed=%lldLL",(long long)TStdExceptionHandler::kSEProceed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandlercLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kSEHandled=%lldLL",(long long)TStdExceptionHandler::kSEHandled).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandlercLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kSEAbort=%lldLL",(long long)TStdExceptionHandler::kSEAbort).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTime */
static void G__setup_memvarTTime(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TTime));
   { TTime *p; p=(TTime*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fMilliSec=",0,"time with millisecond precision");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* FileStat_t */
static void G__setup_memvarFileStat_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_FileStat_t));
   { FileStat_t *p; p=(FileStat_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fDev)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fDev=",0,"device id");
   G__memvar_setup((void*)((long)(&p->fIno)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fIno=",0,"inode");
   G__memvar_setup((void*)((long)(&p->fMode)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMode=",0,"protection (combination of EFileModeMask bits)");
   G__memvar_setup((void*)((long)(&p->fUid)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fUid=",0,"user id of owner");
   G__memvar_setup((void*)((long)(&p->fGid)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fGid=",0,"group id of owner");
   G__memvar_setup((void*)((long)(&p->fSize)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fSize=",0,"total size in bytes");
   G__memvar_setup((void*)((long)(&p->fMtime)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fMtime=",0,"modification date");
   G__memvar_setup((void*)((long)(&p->fIsLink)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fIsLink=",0,"symbolic link");
   G__memvar_setup((void*)((long)(&p->fUrl)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fUrl=",0,"end point url of file");
   }
   G__tag_memvar_reset();
}


   /* UserGroup_t */
static void G__setup_memvarUserGroup_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t));
   { UserGroup_t *p; p=(UserGroup_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fUid)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fUid=",0,"user id");
   G__memvar_setup((void*)((long)(&p->fGid)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fGid=",0,"group id");
   G__memvar_setup((void*)((long)(&p->fUser)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fUser=",0,"user name");
   G__memvar_setup((void*)((long)(&p->fGroup)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fGroup=",0,"group name");
   G__memvar_setup((void*)((long)(&p->fPasswd)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fPasswd=",0,"password");
   G__memvar_setup((void*)((long)(&p->fRealName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fRealName=",0,"user full name");
   G__memvar_setup((void*)((long)(&p->fShell)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fShell=",0,"user preferred shell");
   }
   G__tag_memvar_reset();
}


   /* SysInfo_t */
static void G__setup_memvarSysInfo_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t));
   { SysInfo_t *p; p=(SysInfo_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fOS)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fOS=",0,"OS");
   G__memvar_setup((void*)((long)(&p->fModel)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fModel=",0,"computer model");
   G__memvar_setup((void*)((long)(&p->fCpuType)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fCpuType=",0,"type of cpu");
   G__memvar_setup((void*)((long)(&p->fCpus)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fCpus=",0,"number of cpus");
   G__memvar_setup((void*)((long)(&p->fCpuSpeed)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fCpuSpeed=",0,"cpu speed in MHz");
   G__memvar_setup((void*)((long)(&p->fBusSpeed)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fBusSpeed=",0,"bus speed in MHz");
   G__memvar_setup((void*)((long)(&p->fL2Cache)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fL2Cache=",0,"level 2 cache size in KB");
   G__memvar_setup((void*)((long)(&p->fPhysRam)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPhysRam=",0,"physical RAM in MB");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* CpuInfo_t */
static void G__setup_memvarCpuInfo_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t));
   { CpuInfo_t *p; p=(CpuInfo_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fLoad1m)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fLoad1m=",0,"cpu load average over 1 m");
   G__memvar_setup((void*)((long)(&p->fLoad5m)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fLoad5m=",0,"cpu load average over 5 m");
   G__memvar_setup((void*)((long)(&p->fLoad15m)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fLoad15m=",0,"cpu load average over 15 m");
   G__memvar_setup((void*)((long)(&p->fUser)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fUser=",0,"cpu user load in percentage");
   G__memvar_setup((void*)((long)(&p->fSys)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fSys=",0,"cpu sys load in percentage");
   G__memvar_setup((void*)((long)(&p->fTotal)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fTotal=",0,"cpu user+sys load in percentage");
   G__memvar_setup((void*)((long)(&p->fIdle)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fIdle=",0,"cpu idle percentage");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* MemInfo_t */
static void G__setup_memvarMemInfo_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t));
   { MemInfo_t *p; p=(MemInfo_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fMemTotal)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMemTotal=",0,"total RAM in MB");
   G__memvar_setup((void*)((long)(&p->fMemUsed)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMemUsed=",0,"used RAM in MB");
   G__memvar_setup((void*)((long)(&p->fMemFree)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMemFree=",0,"free RAM in MB");
   G__memvar_setup((void*)((long)(&p->fSwapTotal)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSwapTotal=",0,"total swap in MB");
   G__memvar_setup((void*)((long)(&p->fSwapUsed)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSwapUsed=",0,"used swap in MB");
   G__memvar_setup((void*)((long)(&p->fSwapFree)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSwapFree=",0,"free swap in MB");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ProcInfo_t */
static void G__setup_memvarProcInfo_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t));
   { ProcInfo_t *p; p=(ProcInfo_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fCpuUser)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fCpuUser=",0,"user time used by this process in seconds");
   G__memvar_setup((void*)((long)(&p->fCpuSys)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fCpuSys=",0,"system time used by this process in seconds");
   G__memvar_setup((void*)((long)(&p->fMemResident)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fMemResident=",0,"resident memory used by this process in KB");
   G__memvar_setup((void*)((long)(&p->fMemVirtual)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fMemVirtual=",0,"virtual memory used by this process in KB");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RedirectHandle_t */
static void G__setup_memvarRedirectHandle_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t));
   { RedirectHandle_t *p; p=(RedirectHandle_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fFile)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fFile=",0,"File where the output was redirected");
   G__memvar_setup((void*)((long)(&p->fStdOutTty)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fStdOutTty=",0,"tty associated with stdout, if any (e.g. from ttyname(...))");
   G__memvar_setup((void*)((long)(&p->fStdErrTty)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,1,"fStdErrTty=",0,"tty associated with stderr, if any (e.g. from ttyname(...))");
   G__memvar_setup((void*)((long)(&p->fStdOutDup)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fStdOutDup=",0,"Duplicated descriptor for stdout");
   G__memvar_setup((void*)((long)(&p->fStdErrDup)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fStdErrDup=",0,"Duplicated descriptor for stderr");
   G__memvar_setup((void*)((long)(&p->fReadOffSet)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fReadOffSet=",0,"Offset where to start reading the file (used by ShowOutput(...))");
   }
   G__tag_memvar_reset();
}


   /* TProcessEventTimer */
static void G__setup_memvarTProcessEventTimer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer));
   { TProcessEventTimer *p; p=(TProcessEventTimer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRemoteObject */
static void G__setup_memvarTRemoteObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject));
   { TRemoteObject *p; p=(TRemoteObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_FileStat_t),-1,-1,2,"fFileStat=",0,"file status");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsFolder=",0,"is folder flag");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fRemoteAddress=",0,"remote address");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fClassName=",0,"real object class name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fKeyObjectName=",0,"key object name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fKeyClassName=",0,"key object class name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TROOT */
static void G__setup_memvarTROOT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TROOT));
   { TROOT *p; p=(TROOT*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLineIsProcessing=",0,"To synchronize multi-threads");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgDirLevel=",0,"Indentation level for ls()");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgRootInit=",0,"Singleton initialization flag");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgMemCheck=",0,"Turn on memory leak checker");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fConfigOptions=",0,"ROOT ./configure set build options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fConfigFeatures=",0,"ROOT ./configure detected build features");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fVersion=",0,"ROOT version (from CMZ VERSQQ) ex 0.05/01");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersionInt=",0,"ROOT version in integer format (501)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersionCode=",0,"ROOT version code as used in RVersion.h");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersionDate=",0,"Date of ROOT version (ex 951226)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVersionTime=",0,"Time of ROOT version (ex 1152)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBuiltDate=",0,"Date of ROOT built");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBuiltTime=",0,"Time of ROOT built");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSvnRevision=",0,"Subversion revision number of built");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fSvnBranch=",0,"Subversion branch");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fSvnDate=",0,"Date and time when make was run");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTimer=",0,"Timer flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TApplication),-1,-1,2,"fApplication=",0,"Pointer to current application");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TInterpreter),-1,-1,2,"fInterpreter=",0,"Command interpreter");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBatch=",0,"True if session without graphics");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEditHistograms=",0,"True if histograms can be edited with the mouse");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFromPopUp=",0,"True if command executed from a popup menu");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMustClean=",0,"True if object destructor scans canvases");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReadingObject=",0,"True while reading an object [Deprecated (will be removed in next release)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fForceStyle=",0,"Force setting of current style when reading objects");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInterrupt=",0,"True if macro should be interrupted");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEscape=",0,"True if ESC has been pressed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fExecutingMacro=",0,"True while executing a TMacro");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEditorMode=",0,"Current Editor mode");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Base2LN_TObject),-1,-1,2,"fPrimitive=",0,"Currently selected primitive");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TVirtualPad),-1,-1,2,"fSelectPad=",0,"Currently selected pad");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fClasses=",0,"List of classes definition");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fTypes=",0,"List of data types definition");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fGlobals=",0,"List of global variables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fGlobalFunctions=",0,"List of global functions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fFiles=",0,"List of files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fMappedFiles=",0,"List of memory mapped files");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fSockets=",0,"List of network sockets");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fCanvases=",0,"List of canvases");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fStyles=",0,"List of styles");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fFunctions=",0,"List of analytic functions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fTasks=",0,"List of tasks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fColors=",0,"List of colors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fGeometries=",0,"List of geometries");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fBrowsers=",0,"List of browsers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fSpecials=",0,"List of special objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fCleanups=",0,"List of recursiveRemove collections");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fMessageHandlers=",0,"List of message handlers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fStreamerInfo=",0,"List of active StreamerInfo classes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TCollection),-1,-1,2,"fClassGenerators=",0,"List of user defined class generators;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fSecContexts=",0,"List of security contexts (TSecContext)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fProofs=",0,"List of proof sessions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fClipboard=",0,"List of clipbard objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection),-1,-1,2,"fDataSets=",0,"List of data sets (TDSet or TChain)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID),-1,-1,2,"fUUIDs=",0,"Pointer to TProcessID managing TUUIDs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TFolder),-1,-1,2,"fRootFolder=",0,"top level folder //root");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fBrowsables=",0,"List of browsables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TPluginManager),-1,-1,2,"fPluginManager=",0,"Keeps track of plugin library handlers");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fCutClassName=",0,"Name of default CutG class in graphics editor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fDefCanvasName=",0,"Name of default canvas");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTask */
static void G__setup_memvarTTask(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_TTask));
   { TTask *p; p=(TTask*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TList),-1,-1,2,"fTasks=",0,"List of Tasks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Base2LN_TString),-1,-1,2,"fOption=",0,"Option specified in ExecuteTask");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBreakin=",0,"=1 if a break point set at task extry");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBreakout=",0,"=1 if a break point set at task exit");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasExecuted=",0,"True if task has executed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"true if task is active");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TTask),-1,-2,2,"fgBeginTask=",0,"pointer to task initiator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TTask),-1,-2,2,"fgBreakPoint=",0,"pointer to current break point");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Base2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* vector<string,allocator<string> > */
static void G__setup_memvarvectorlEstringcOallocatorlEstringgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   { vector<string,allocator<string> > *p; p=(vector<string,allocator<string> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<string,allocator<string> >::iterator */
static void G__setup_memvarvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   { vector<string,allocator<string> >::iterator *p; p=(vector<string,allocator<string> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* reverse_iterator<vector<string,allocator<string> >::iterator> */
static void G__setup_memvarreverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   { reverse_iterator<vector<string,allocator<string> >::iterator> *p; p=(reverse_iterator<vector<string,allocator<string> >::iterator>*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Base2() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMemberInspector(void) {
   /* TMemberInspector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TMemberInspector));
   G__memfunc_setup("Inspect",726,G__G__Base2_9_0_2, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TClass' - 0 - cl C - - 10 - parent "
"C - - 10 - name Y - - 10 - addr", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetParent",906,G__G__Base2_9_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParentLen",1193,G__G__Base2_9_0_4, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToParent",1078,G__G__Base2_9_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveFromParent",1644,G__G__Base2_9_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - startingAt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectMember",1326,G__G__Base2_9_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TObject' - 1 - obj C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectMember",1326,G__G__Base2_9_0_8, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - topclassname Y - - 0 - pobj "
"C - - 10 - name g - 'Bool_t' 0 - transient", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectMember",1326,G__G__Base2_9_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl Y - - 0 - pobj "
"C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenericShowMembers",1833,G__G__Base2_9_0_10, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - topClassName Y - - 0 - obj "
"g - 'Bool_t' 0 - transientMember", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_9_0_11, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMemberInspector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_9_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMemberInspector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_9_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMemberInspector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_9_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMemberInspector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_9_0_15, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_9_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_9_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_9_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_9_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMemberInspector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_9_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMemberInspector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_9_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMemberInspector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_9_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMemberInspector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMemberInspector", 1761, G__G__Base2_9_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_9_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TMemberInspector), -1, 1, 1, 1, 1, 0, "u 'TMemberInspector' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObject(void) {
   /* TObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TObject));
   G__memfunc_setup("MakeZombie",996,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoError",701,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 8, 
"i - - 0 - level C - - 10 - location "
"C - - 10 - fmt u 'va_list' - 0 - va", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TObject",683,G__G__Base2_10_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObject",683,G__G__Base2_10_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 0, "u 'TObject' - 11 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_10_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 1, 1, 1, 1, 0, "u 'TObject' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AppendPad",877,G__G__Base2_10_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,G__G__Base2_10_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassName",887,G__G__Base2_10_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,G__G__Base2_10_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clone",497,G__G__Base2_10_0_10, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compare",711,G__G__Base2_10_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,G__G__Base2_10_0_12, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - object", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,G__G__Base2_10_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,G__G__Base2_10_0_14, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Base2_10_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawClass",900,G__G__Base2_10_0_16, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawClone",895,G__G__Base2_10_0_17, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Dump",406,G__G__Base2_10_0_18, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Execute",723,G__G__Base2_10_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - method C - - 10 - params "
"I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Execute",723,G__G__Base2_10_0_20, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TMethod' - 0 - method U 'TObjArray' - 0 - params "
"I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,G__G__Base2_10_0_21, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,G__G__Base2_10_0_22, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,G__G__Base2_10_0_23, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDrawOption",1319,G__G__Base2_10_0_24, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUniqueID",1060,G__G__Base2_10_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,G__G__Base2_10_0_26, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIconName",1066,G__G__Base2_10_0_27, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,G__G__Base2_10_0_28, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,G__G__Base2_10_0_29, 67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,G__G__Base2_10_0_30, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleTimer",1101,G__G__Base2_10_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,G__G__Base2_10_0_32, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InheritsFrom",1242,G__G__Base2_10_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - classname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InheritsFrom",1242,G__G__Base2_10_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TClass' - 10 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Inspect",726,G__G__Base2_10_0_35, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,G__G__Base2_10_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEqual",692,G__G__Base2_10_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSortable",1016,G__G__Base2_10_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnHeap",759,G__G__Base2_10_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsZombie",802,G__G__Base2_10_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,G__G__Base2_10_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,G__G__Base2_10_0_42, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,G__G__Base2_10_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pop",303,G__G__Base2_10_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Base2_10_0_45, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Read",380,G__G__Base2_10_0_46, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,G__G__Base2_10_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveAs",579,G__G__Base2_10_0_48, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"\"' filename C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Base2_10_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawOption",1331,G__G__Base2_10_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetUniqueID",1072,G__G__Base2_10_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - uid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseCurrentStyle",1569,G__G__Base2_10_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,G__G__Base2_10_0_53, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,G__G__Base2_10_0_54, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator new",1238,G__G__Base2_10_0_55, 89, -1, -1, 0, 1, 1, 1, 0, "h - 'size_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator new[]",1422,G__G__Base2_10_0_56, 89, -1, -1, 0, 1, 1, 1, 0, "h - 'size_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator new",1238,G__G__Base2_10_0_57, 89, -1, -1, 0, 2, 1, 1, 0, 
"h - 'size_t' 0 - sz Y - - 0 - vp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator new[]",1422,G__G__Base2_10_0_58, 89, -1, -1, 0, 2, 1, 1, 0, 
"h - 'size_t' 0 - sz Y - - 0 - vp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator delete",1535,G__G__Base2_10_0_59, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - ptr", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TObject::operator delete) ), 0);
   G__memfunc_setup("operator delete[]",1719,G__G__Base2_10_0_60, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - ptr", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TObject::operator delete[]) ), 0);
   G__memfunc_setup("operator delete",1535,G__G__Base2_10_0_61, 121, -1, -1, 0, 2, 3, 1, 0, 
"Y - - 0 - ptr Y - - 0 - vp", (char*)NULL, (void*) G__func2void( (void (*)(void*, void*))(&TObject::operator delete) ), 0);
   G__memfunc_setup("operator delete[]",1719,G__G__Base2_10_0_62, 121, -1, -1, 0, 2, 3, 1, 0, 
"Y - - 0 - ptr Y - - 0 - vp", (char*)NULL, (void*) G__func2void( (void (*)(void*, void*))(&TObject::operator delete[]) ), 0);
   G__memfunc_setup("SetBit",587,G__G__Base2_10_0_63, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - f g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBit",587,G__G__Base2_10_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetBit",802,G__G__Base2_10_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestBit",703,G__G__Base2_10_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestBits",818,G__G__Base2_10_0_67, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvertBit",919,G__G__Base2_10_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Info",396,G__G__Base2_10_0_69, 121, -1, -1, 0, 2, 8, 1, 8, 
"C - - 10 - method C - - 10 - msgfmt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Warning",726,G__G__Base2_10_0_70, 121, -1, -1, 0, 2, 8, 1, 8, 
"C - - 10 - method C - - 10 - msgfmt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Error",522,G__G__Base2_10_0_71, 121, -1, -1, 0, 2, 8, 1, 8, 
"C - - 10 - method C - - 10 - msgfmt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SysError",841,G__G__Base2_10_0_72, 121, -1, -1, 0, 2, 8, 1, 8, 
"C - - 10 - method C - - 10 - msgfmt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fatal",488,G__G__Base2_10_0_73, 121, -1, -1, 0, 2, 8, 1, 8, 
"C - - 10 - method C - - 10 - msgfmt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AbstractMethod",1429,G__G__Base2_10_0_74, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MayNotUse",901,G__G__Base2_10_0_75, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDtorOnly",1115,G__G__Base2_10_0_76, 108, -1, G__defined_typename("Long_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long_t (*)())(&TObject::GetDtorOnly) ), 0);
   G__memfunc_setup("SetDtorOnly",1127,G__G__Base2_10_0_77, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - obj", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TObject::SetDtorOnly) ), 0);
   G__memfunc_setup("GetObjectStat",1299,G__G__Base2_10_0_78, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TObject::GetObjectStat) ), 0);
   G__memfunc_setup("SetObjectStat",1311,G__G__Base2_10_0_79, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - stat", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TObject::SetObjectStat) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_10_0_80, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_10_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_10_0_82, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_10_0_83, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_10_0_84, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_10_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_10_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_10_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_10_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_10_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_10_0_90, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_10_0_91, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObject::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TObject", 809, G__G__Base2_10_0_92, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTNamed(void) {
   /* TNamed */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TNamed));
   G__memfunc_setup("TNamed",569,G__G__Base2_11_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TNamed), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNamed",569,G__G__Base2_11_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TNamed), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNamed",569,G__G__Base2_11_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TNamed), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - name u 'TString' - 11 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNamed",569,G__G__Base2_11_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TNamed), -1, 0, 1, 1, 1, 0, "u 'TNamed' - 11 - named", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_11_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_TNamed), -1, 1, 1, 1, 1, 0, "u 'TNamed' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - named", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,G__G__Base2_11_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,G__G__Base2_11_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNameTitle",1199,G__G__Base2_11_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Base2_11_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' title", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,G__G__Base2_11_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_11_0_21, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNamed::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_11_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNamed::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_11_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNamed::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_11_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNamed::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_11_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_11_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNamed::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_11_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNamed::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_11_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNamed::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_11_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNamed::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNamed", 695, G__G__Base2_11_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTString(void) {
   /* TString */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TString));
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "Make self a distinct copy", (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Ssiz_t' 0 - nc", "Make self a distinct copy w. capacity nc", (void*) NULL, 0);
   G__memfunc_setup("FormImp",698,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"C - - 10 - fmt u 'va_list' - 0 - ap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TString",715,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 4, 1, 2, 0, 
"C - - 10 - a1 i - 'Ssiz_t' 0 - n1 "
"C - - 10 - a2 i - 'Ssiz_t' 0 - n2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Pref",397,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Base2LN_TStringRef), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertElement",1340,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "i - 'Ssiz_t' 0 - nc", "Index in range", (void*) NULL, 0);
   G__memfunc_setup("Clobber",697,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Ssiz_t' 0 - nc", "Remove old contents", (void*) NULL, 0);
   G__memfunc_setup("Cow",297,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Do copy on write as needed", (void*) NULL, 0);
   G__memfunc_setup("Cow",297,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Ssiz_t' 0 - nc", "Do copy on write as needed", (void*) NULL, 0);
   G__memfunc_setup("AdjustCapacity",1433,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 3, 2, 0, "i - 'Ssiz_t' 0 - nc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitChar",786,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "c - - 0 - c", "Initialize from char", (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_12, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 0, 1, 1, 0, "", "Null string", (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_13, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 5, 1, 0, "i - 'Ssiz_t' 0 - ic", "Suggested capacity", (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_14, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_15, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "C - - 10 - s", "Copy to embedded null", (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_16, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 2, 1, 1, 0, 
"C - - 10 - s i - 'Ssiz_t' 0 - n", "Copy past any embedded nulls", (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_17, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_18, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_19, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 2, 1, 1, 0, 
"c - - 0 - c i - 'Ssiz_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TString",715,G__G__Base2_13_0_20, 105, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "u 'TSubString' - 11 - sub", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBuffer",993,G__G__Base2_13_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__Base2_13_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,G__G__Base2_13_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadString",1011,G__G__Base2_13_0_24, 85, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 2, 3, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClass' - 10 - clReq", (char*)NULL, (void*) G__func2void( (TString* (*)(TBuffer&, const TClass*))(&TString::ReadString) ), 0);
   G__memfunc_setup("WriteString",1154,G__G__Base2_13_0_25, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'TBuffer' - 1 - b U 'TString' - 10 - a", (char*)NULL, (void*) G__func2void( (void (*)(TBuffer&, const TString*))(&TString::WriteString) ), 0);
   G__memfunc_setup("Gets",403,G__G__Base2_13_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"E - - 0 - fp g - 'Bool_t' 0 'kTRUE' chop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Puts",428,G__G__Base2_13_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "E - - 0 - fp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const char*",1947,G__G__Base2_13_0_28, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_13_0_29, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "c - - 0 - s", "Replace string", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_13_0_30, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_13_0_31, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_13_0_32, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_13_0_33, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "u 'TSubString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_34, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "C - - 10 - cs", "Append string", (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_35, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_36, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_37, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "s - 'Short_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_38, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "r - 'UShort_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_39, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_40, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_41, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "l - 'Long_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_42, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "k - 'ULong_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_43, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_44, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_45, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "n - 'Long64_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_13_0_46, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "m - 'ULong64_t' 0 - ul", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_13_0_47, 99, -1, -1, 1, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - i", "Indexing with bounds checking", (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_48, 99, -1, -1, 1, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - i", "Indexing with optional bounds checking", (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_13_0_49, 99, -1, -1, 0, 1, 1, 1, 8, "i - 'Ssiz_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_50, 99, -1, -1, 0, 1, 1, 1, 8, "i - 'Ssiz_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_51, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 2, 1, 1, 8, 
"i - 'Ssiz_t' 0 - start i - 'Ssiz_t' 0 - len", "Sub-string operator", (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_52, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 1, 1, 1, 8, "u 'TRegexp' - 11 - re", "Match the RE", (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_53, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 2, 1, 1, 8, 
"u 'TRegexp' - 11 - re i - 'Ssiz_t' 0 - start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_54, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 1, 1, 1, 8, "u 'TPRegexp' - 1 - re", "Match the Perl compatible Regular Expression", (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_13_0_55, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 2, 1, 1, 8, 
"u 'TPRegexp' - 1 - re i - 'Ssiz_t' 0 - start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SubString",929,G__G__Base2_13_0_56, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 3, 1, 1, 8, 
"C - - 10 - pat i - 'Ssiz_t' 0 '0' start "
"i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__Base2_13_0_57, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "C - - 10 - cs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__Base2_13_0_58, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"C - - 10 - cs i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__Base2_13_0_59, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__Base2_13_0_60, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"u 'TString' - 11 - s i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__Base2_13_0_61, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"c - - 0 - c i - 'Ssiz_t' 0 '1' rep", "Append c rep times", (void*) NULL, 0);
   G__memfunc_setup("Atoi",397,G__G__Base2_13_0_62, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Atoll",508,G__G__Base2_13_0_63, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Atof",394,G__G__Base2_13_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginsWith",1012,G__G__Base2_13_0_65, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginsWith",1012,G__G__Base2_13_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"u 'TString' - 11 - pat i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,G__G__Base2_13_0_67, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,G__G__Base2_13_0_68, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chop",394,G__G__Base2_13_0_69, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__G__Base2_13_0_70, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareTo",906,G__G__Base2_13_0_71, 105, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - cs i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompareTo",906,G__G__Base2_13_0_72, 105, -1, -1, 0, 2, 1, 1, 8, 
"u 'TString' - 11 - st i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Base2_13_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Base2_13_0_74, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"u 'TString' - 11 - pat i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Base2_13_0_75, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TRegexp' - 11 - pat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Base2_13_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TPRegexp' - 1 - pat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountChar",903,G__G__Base2_13_0_77, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Base2_13_0_78, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Data",378,G__G__Base2_13_0_79, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndsWith",806,G__G__Base2_13_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"C - - 10 - pat i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("First",520,G__G__Base2_13_0_81, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 1, 8, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("First",520,G__G__Base2_13_0_82, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 1, 8, "C - - 10 - cs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Form",404,G__G__Base2_13_0_83, 121, -1, -1, 0, 1, 8, 1, 0, "C - - 10 - fmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hash",388,G__G__Base2_13_0_84, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_85, 105, -1, G__defined_typename("Ssiz_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s i - 'Ssiz_t' 0 '0' i "
"i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_86, 105, -1, G__defined_typename("Ssiz_t"), 0, 3, 1, 1, 8, 
"u 'TString' - 11 - s i - 'Ssiz_t' 0 '0' i "
"i 'TString::ECaseCompare' - 0 'kExact' cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_87, 105, -1, G__defined_typename("Ssiz_t"), 0, 4, 1, 1, 8, 
"C - - 10 - pat i - 'Ssiz_t' 0 - patlen "
"i - 'Ssiz_t' 0 - i i 'TString::ECaseCompare' - 0 - cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_88, 105, -1, G__defined_typename("Ssiz_t"), 0, 4, 1, 1, 8, 
"u 'TString' - 11 - pat i - 'Ssiz_t' 0 - patlen "
"i - 'Ssiz_t' 0 - i i 'TString::ECaseCompare' - 0 - cmp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_89, 105, -1, G__defined_typename("Ssiz_t"), 0, 2, 1, 1, 8, 
"u 'TRegexp' - 11 - pat i - 'Ssiz_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_90, 105, -1, G__defined_typename("Ssiz_t"), 0, 3, 1, 1, 8, 
"u 'TRegexp' - 11 - pat I - 'Ssiz_t' 0 - ext "
"i - 'Ssiz_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_91, 105, -1, G__defined_typename("Ssiz_t"), 0, 2, 1, 1, 8, 
"u 'TPRegexp' - 1 - pat i - 'Ssiz_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_13_0_92, 105, -1, G__defined_typename("Ssiz_t"), 0, 3, 1, 1, 8, 
"u 'TPRegexp' - 1 - pat I - 'Ssiz_t' 0 - ext "
"i - 'Ssiz_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,G__G__Base2_13_0_93, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos C - - 10 - cs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,G__G__Base2_13_0_94, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 3, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos C - - 10 - cs "
"i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,G__G__Base2_13_0_95, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,G__G__Base2_13_0_96, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 3, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos u 'TString' - 11 - s "
"i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAscii",677,G__G__Base2_13_0_97, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAlpha",674,G__G__Base2_13_0_98, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAlnum",697,G__G__Base2_13_0_99, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDigit",685,G__G__Base2_13_0_100, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFloat",690,G__G__Base2_13_0_101, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHex",481,G__G__Base2_13_0_102, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNull",599,G__G__Base2_13_0_103, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsWhitespace",1225,G__G__Base2_13_0_104, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Last",404,G__G__Base2_13_0_105, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 1, 8, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Length",610,G__G__Base2_13_0_106, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MaybeRegexp",1113,G__G__Base2_13_0_107, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MaybeWildcard",1304,G__G__Base2_13_0_108, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Prepend",718,G__G__Base2_13_0_109, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "C - - 10 - cs", "Prepend a character string", (void*) NULL, 0);
   G__memfunc_setup("Prepend",718,G__G__Base2_13_0_110, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"C - - 10 - cs i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Prepend",718,G__G__Base2_13_0_111, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Prepend",718,G__G__Base2_13_0_112, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"u 'TString' - 11 - s i - 'Ssiz_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Prepend",718,G__G__Base2_13_0_113, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"c - - 0 - c i - 'Ssiz_t' 0 '1' rep", "Prepend c rep times", (void*) NULL, 0);
   G__memfunc_setup("ReadFile",764,G__G__Base2_13_0_114, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - str", "Read to EOF or null character", (void*) NULL, 0);
   G__memfunc_setup("ReadLine",772,G__G__Base2_13_0_115, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - str g - 'Bool_t' 0 'kTRUE' skipWhite", "Read to EOF or newline", (void*) NULL, 0);
   G__memfunc_setup("ReadString",1011,G__G__Base2_13_0_116, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - str", "Read to EOF or null character", (void*) NULL, 0);
   G__memfunc_setup("ReadToDelim",1066,G__G__Base2_13_0_117, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - str c - - 0 ''\\n'' delim", "Read to EOF or delimitor", (void*) NULL, 0);
   G__memfunc_setup("ReadToken",893,G__G__Base2_13_0_118, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - str", "Read separated by white space", (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Base2_13_0_119, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - pos", "Remove pos to end of string", (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Base2_13_0_120, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos i - 'Ssiz_t' 0 - n", "Remove n chars starting at pos", (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Base2_13_0_121, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"i 'TString::EStripType' - 0 - s c - - 0 - c", "Like Strip() but changing string directly", (void*) NULL, 0);
   G__memfunc_setup("Replace",700,G__G__Base2_13_0_122, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 3, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos i - 'Ssiz_t' 0 - n "
"C - - 10 - cs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Replace",700,G__G__Base2_13_0_123, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 4, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos i - 'Ssiz_t' 0 - n "
"C - - 10 - s i - 'Ssiz_t' 0 - ns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Replace",700,G__G__Base2_13_0_124, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 3, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos i - 'Ssiz_t' 0 - n "
"u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Replace",700,G__G__Base2_13_0_125, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 4, 1, 1, 0, 
"i - 'Ssiz_t' 0 - pos i - 'Ssiz_t' 0 - n1 "
"u 'TString' - 11 - s i - 'Ssiz_t' 0 - n2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReplaceAll",981,G__G__Base2_13_0_126, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"u 'TString' - 11 - s1 u 'TString' - 11 - s2", "Find&Replace all s1 with s2 if any", (void*) NULL, 0);
   G__memfunc_setup("ReplaceAll",981,G__G__Base2_13_0_127, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"u 'TString' - 11 - s1 C - - 10 - s2", "Find&Replace all s1 with s2 if any", (void*) NULL, 0);
   G__memfunc_setup("ReplaceAll",981,G__G__Base2_13_0_128, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"C - - 10 - s1 u 'TString' - 11 - s2", "Find&Replace all s1 with s2 if any", (void*) NULL, 0);
   G__memfunc_setup("ReplaceAll",981,G__G__Base2_13_0_129, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 2, 1, 1, 0, 
"C - - 10 - s1 C - - 10 - s2", "Find&Replace all s1 with s2 if any", (void*) NULL, 0);
   G__memfunc_setup("ReplaceAll",981,G__G__Base2_13_0_130, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 4, 1, 1, 0, 
"C - - 10 - s1 i - 'Ssiz_t' 0 - ls1 "
"C - - 10 - s2 i - 'Ssiz_t' 0 - ls2", "Find&Replace all s1 with s2 if any", (void*) NULL, 0);
   G__memfunc_setup("Resize",626,G__G__Base2_13_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - n", "Truncate or add blanks as necessary", (void*) NULL, 0);
   G__memfunc_setup("Strip",530,G__G__Base2_13_0_132, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 2, 1, 1, 8, 
"i 'TString::EStripType' - 0 'kTrailing' s c - - 0 '' '' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToLower",716,G__G__Base2_13_0_133, 121, -1, -1, 0, 0, 1, 1, 0, "", "Change self to lower-case", (void*) NULL, 0);
   G__memfunc_setup("ToUpper",719,G__G__Base2_13_0_134, 121, -1, -1, 0, 0, 1, 1, 0, "", "Change self to upper-case", (void*) NULL, 0);
   G__memfunc_setup("Tokenize",841,G__G__Base2_13_0_135, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjArray), -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - delim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Tokenize",841,G__G__Base2_13_0_136, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"u 'TString' - 1 - tok i - 'Ssiz_t' 1 - from "
"C - - 10 '\" \"' delim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hash",388,G__G__Base2_13_0_137, 104, -1, G__defined_typename("UInt_t"), 0, 2, 3, 1, 0, 
"Y - - 10 - txt i - 'Int_t' 0 - ntxt", "Calculates hash index from any char string.", (void*) G__func2void( (UInt_t (*)(const void*, Int_t))(&TString::Hash) ), 0);
   G__memfunc_setup("InitialCapacity",1528,G__G__Base2_13_0_138, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 3, 1, 0, "i - 'Ssiz_t' 0 '15' ic", "Initial allocation capacity", (void*) G__func2void( (Ssiz_t (*)(Ssiz_t))(&TString::InitialCapacity) ), 0);
   G__memfunc_setup("MaxWaste",810,G__G__Base2_13_0_139, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 3, 1, 0, "i - 'Ssiz_t' 0 '15' mw", "Max empty space before reclaim", (void*) G__func2void( (Ssiz_t (*)(Ssiz_t))(&TString::MaxWaste) ), 0);
   G__memfunc_setup("ResizeIncrement",1559,G__G__Base2_13_0_140, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 3, 1, 0, "i - 'Ssiz_t' 0 '16' ri", "Resizing increment", (void*) G__func2void( (Ssiz_t (*)(Ssiz_t))(&TString::ResizeIncrement) ), 0);
   G__memfunc_setup("GetInitialCapacity",1816,G__G__Base2_13_0_141, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Ssiz_t (*)())(&TString::GetInitialCapacity) ), 0);
   G__memfunc_setup("GetResizeIncrement",1847,G__G__Base2_13_0_142, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Ssiz_t (*)())(&TString::GetResizeIncrement) ), 0);
   G__memfunc_setup("GetMaxWaste",1098,G__G__Base2_13_0_143, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Ssiz_t (*)())(&TString::GetMaxWaste) ), 0);
   G__memfunc_setup("Format",617,G__G__Base2_13_0_144, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 10, 1, 0, "C - - 10 - fmt", (char*)NULL, (void*) G__func2void( (TString (*)(const char*))(&TString::Format) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_13_0_145, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TString::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_13_0_146, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TString::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_13_0_147, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TString::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_13_0_148, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TString::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_13_0_149, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_13_0_150, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_13_0_151, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_13_0_152, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_13_0_153, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TString::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_13_0_154, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TString::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_13_0_155, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TString::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_13_0_156, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TString::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TString", 841, G__G__Base2_13_0_157, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncstring(void) {
   /* string */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_string));
   G__memfunc_setup("string",663,G__G__Base2_53_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("string",663,G__G__Base2_53_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("string",663,G__G__Base2_53_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - str h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("string",663,G__G__Base2_53_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"C - - 10 - s h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("string",663,G__G__Base2_53_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("string",663,G__G__Base2_53_0_6, 105, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"h - 'size_t' 0 - rep c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_53_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_53_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_53_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_53_0_10, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_53_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_53_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("append",632,G__G__Base2_53_0_13, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("append",632,G__G__Base2_53_0_14, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 3, 1, 1, 0, 
"u 'string' - 11 - str h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("append",632,G__G__Base2_53_0_15, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 2, 1, 1, 0, 
"C - - 10 - s h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("append",632,G__G__Base2_53_0_16, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("append",632,G__G__Base2_53_0_17, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 2, 1, 1, 0, 
"h - 'size_t' 0 - rep c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("assign",645,G__G__Base2_53_0_18, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("assign",645,G__G__Base2_53_0_19, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 3, 1, 1, 0, 
"u 'string' - 11 - str h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("assign",645,G__G__Base2_53_0_20, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 2, 1, 1, 0, 
"C - - 10 - s h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("assign",645,G__G__Base2_53_0_21, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("assign",645,G__G__Base2_53_0_22, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 2, 1, 1, 0, 
"h - 'size_t' 0 - rep c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_53_0_23, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 2, 1, 1, 0, 
"h - 'size_t' 0 - pos1 u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_53_0_24, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 4, 1, 1, 0, 
"h - 'size_t' 0 - pos1 u 'string' - 11 - str "
"h - 'size_t' 0 - pos2 h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_53_0_25, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 3, 1, 1, 0, 
"h - 'size_t' 0 - pos C - - 10 - s "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_53_0_26, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 2, 1, 1, 0, 
"h - 'size_t' 0 - pos C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_53_0_27, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 3, 1, 1, 0, 
"h - 'size_t' 0 - pos h - 'size_t' 0 - rep "
"c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("replace",732,G__G__Base2_53_0_28, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 3, 1, 1, 0, 
"h - 'size_t' 0 - pos1 h - 'size_t' 0 - n1 "
"u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("replace",732,G__G__Base2_53_0_29, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 5, 1, 1, 0, 
"h - 'size_t' 0 - pos1 h - 'size_t' 0 - n1 "
"u 'string' - 11 - str h - 'size_t' 0 - pos2 "
"h - 'size_t' 0 - n2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("replace",732,G__G__Base2_53_0_30, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 4, 1, 1, 0, 
"h - 'size_t' 0 - pos h - 'size_t' 0 - n1 "
"C - - 10 - s h - 'size_t' 0 - n2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("replace",732,G__G__Base2_53_0_31, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 3, 1, 1, 0, 
"h - 'size_t' 0 - pos h - 'size_t' 0 - n1 "
"C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("replace",732,G__G__Base2_53_0_32, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 4, 1, 1, 0, 
"h - 'size_t' 0 - pos h - 'size_t' 0 - n "
"h - 'size_t' 0 - rep c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_53_0_33, 99, -1, -1, 1, 1, 1, 1, 9, "h - 'size_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_53_0_34, 99, -1, -1, 1, 1, 1, 1, 0, "h - 'size_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__G__Base2_53_0_35, 99, -1, -1, 1, 1, 1, 1, 9, "h - 'size_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__G__Base2_53_0_36, 99, -1, -1, 1, 1, 1, 1, 0, "h - 'size_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("c_str",539,G__G__Base2_53_0_37, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("data",410,G__G__Base2_53_0_38, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("length",642,G__G__Base2_53_0_39, 104, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Base2_53_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'size_t' 0 - n c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Base2_53_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Base2_53_0_42, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__G__Base2_53_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'size_t' 0 - res_arg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("copy",443,G__G__Base2_53_0_44, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 0, 
"C - - 0 - s h - 'size_t' 0 - n "
"h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__G__Base2_53_0_45, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"u 'string' - 11 - str h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__G__Base2_53_0_46, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__G__Base2_53_0_47, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__G__Base2_53_0_48, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"c - - 0 - c h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rfind",531,G__G__Base2_53_0_49, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"u 'string' - 11 - str h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rfind",531,G__G__Base2_53_0_50, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rfind",531,G__G__Base2_53_0_51, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rfind",531,G__G__Base2_53_0_52, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"c - - 0 - c h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_of",1372,G__G__Base2_53_0_53, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"u 'string' - 11 - str h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_of",1372,G__G__Base2_53_0_54, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_of",1372,G__G__Base2_53_0_55, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_of",1372,G__G__Base2_53_0_56, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"c - - 0 - c h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_of",1256,G__G__Base2_53_0_57, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"u 'string' - 11 - str h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_of",1256,G__G__Base2_53_0_58, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_of",1256,G__G__Base2_53_0_59, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_of",1256,G__G__Base2_53_0_60, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"c - - 0 - c h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_not_of",1804,G__G__Base2_53_0_61, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"u 'string' - 11 - str h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_not_of",1804,G__G__Base2_53_0_62, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_not_of",1804,G__G__Base2_53_0_63, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_first_not_of",1804,G__G__Base2_53_0_64, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"c - - 0 - c h - 'size_t' 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_not_of",1688,G__G__Base2_53_0_65, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"u 'string' - 11 - str h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_not_of",1688,G__G__Base2_53_0_66, 104, -1, G__defined_typename("size_t"), 0, 3, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 - pos "
"h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_not_of",1688,G__G__Base2_53_0_67, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"C - - 10 - s h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find_last_not_of",1688,G__G__Base2_53_0_68, 104, -1, G__defined_typename("size_t"), 0, 2, 1, 1, 8, 
"c - - 0 - c h - 'size_t' 0 'npos' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("substr",675,G__G__Base2_53_0_69, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 8, 
"h - 'size_t' 0 '0' pos h - 'size_t' 0 'npos' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("compare",743,G__G__Base2_53_0_70, 105, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("compare",743,G__G__Base2_53_0_71, 105, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Base2_53_0_72, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Base2_53_0_73, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), G__defined_typename("string::const_iterator"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Base2_53_0_74, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Base2_53_0_75, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), G__defined_typename("string::const_iterator"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__G__Base2_53_0_76, 104, -1, G__defined_typename("string::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Base2_53_0_77, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Base2_53_0_78, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Base2_53_0_79, 104, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~string", 789, G__G__Base2_53_0_80, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncstringcLcLiterator(void) {
   /* string::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Base2_65_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Base2_65_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 1, 5, 1, 0, "C - 'string::pointer' 11 - __i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Base2_65_0_3, 99, -1, G__defined_typename("string::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Base2_65_0_4, 67, -1, G__defined_typename("string::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_65_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_65_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_65_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_65_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_65_0_9, 99, -1, G__defined_typename("string::reference"), 1, 1, 1, 1, 8, "l - 'string::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_65_0_10, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'string::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Base2_65_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'string::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Base2_65_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'string::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Base2_65_0_13, 117, G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'string::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Base2_65_0_14, 67, -1, G__defined_typename("string::pointer"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("iterator", 874, G__G__Base2_65_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'string::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Base2_65_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_65_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_stringcLcLiterator), -1, 1, 1, 1, 1, 0, "u 'string::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStorage(void) {
   /* TStorage */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TStorage));
   G__memfunc_setup("GetHeapBegin",1155,G__G__Base2_73_0_1, 107, -1, G__defined_typename("ULong_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ULong_t (*)())(&TStorage::GetHeapBegin) ), 0);
   G__memfunc_setup("GetHeapEnd",949,G__G__Base2_73_0_2, 107, -1, G__defined_typename("ULong_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ULong_t (*)())(&TStorage::GetHeapEnd) ), 0);
   G__memfunc_setup("GetFreeHook",1075,G__G__Base2_73_0_3, 89, -1, G__defined_typename("FreeHookFun_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FreeHookFun_t (*)())(&TStorage::GetFreeHook) ), 0);
   G__memfunc_setup("GetFreeHookData",1453,G__G__Base2_73_0_4, 89, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void* (*)())(&TStorage::GetFreeHookData) ), 0);
   G__memfunc_setup("GetMaxBlockSize",1484,G__G__Base2_73_0_5, 104, -1, G__defined_typename("size_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (size_t (*)())(&TStorage::GetMaxBlockSize) ), 0);
   G__memfunc_setup("Alloc",491,G__G__Base2_73_0_6, 89, -1, -1, 0, 1, 3, 1, 0, "h - 'size_t' 0 - size", (char*)NULL, (void*) G__func2void( (void* (*)(size_t))(&TStorage::Alloc) ), 0);
   G__memfunc_setup("Dealloc",692,G__G__Base2_73_0_7, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - ptr", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TStorage::Dealloc) ), 0);
   G__memfunc_setup("ReAlloc",674,G__G__Base2_73_0_8, 89, -1, -1, 0, 2, 3, 1, 0, 
"Y - - 0 - vp h - 'size_t' 0 - size", (char*)NULL, (void*) G__func2void( (void* (*)(void*, size_t))(&TStorage::ReAlloc) ), 0);
   G__memfunc_setup("ReAlloc",674,G__G__Base2_73_0_9, 89, -1, -1, 0, 3, 3, 1, 0, 
"Y - - 0 - vp h - 'size_t' 0 - size "
"h - 'size_t' 0 - oldsize", (char*)NULL, (void*) G__func2void( (void* (*)(void*, size_t, size_t))(&TStorage::ReAlloc) ), 0);
   G__memfunc_setup("ReAllocChar",1056,G__G__Base2_73_0_10, 67, -1, -1, 0, 3, 3, 1, 0, 
"C - - 0 - vp h - 'size_t' 0 - size "
"h - 'size_t' 0 - oldsize", (char*)NULL, (void*) G__func2void( (char* (*)(char*, size_t, size_t))(&TStorage::ReAllocChar) ), 0);
   G__memfunc_setup("ReAllocInt",973,G__G__Base2_73_0_11, 73, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"I - 'Int_t' 0 - vp h - 'size_t' 0 - size "
"h - 'size_t' 0 - oldsize", (char*)NULL, (void*) G__func2void( (Int_t* (*)(Int_t*, size_t, size_t))(&TStorage::ReAllocInt) ), 0);
   G__memfunc_setup("ObjectAlloc",1090,G__G__Base2_73_0_12, 89, -1, -1, 0, 1, 3, 1, 0, "h - 'size_t' 0 - size", (char*)NULL, (void*) G__func2void( (void* (*)(size_t))(&TStorage::ObjectAlloc) ), 0);
   G__memfunc_setup("ObjectAlloc",1090,G__G__Base2_73_0_13, 89, -1, -1, 0, 2, 3, 1, 0, 
"h - 'size_t' 0 - size Y - - 0 - vp", (char*)NULL, (void*) G__func2void( (void* (*)(size_t, void*))(&TStorage::ObjectAlloc) ), 0);
   G__memfunc_setup("ObjectDealloc",1291,G__G__Base2_73_0_14, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - vp", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TStorage::ObjectDealloc) ), 0);
   G__memfunc_setup("ObjectDealloc",1291,G__G__Base2_73_0_15, 121, -1, -1, 0, 2, 3, 1, 0, 
"Y - - 0 - vp Y - - 0 - ptr", (char*)NULL, (void*) G__func2void( (void (*)(void*, void*))(&TStorage::ObjectDealloc) ), 0);
   G__memfunc_setup("EnterStat",922,G__G__Base2_73_0_16, 121, -1, -1, 0, 2, 3, 1, 0, 
"h - 'size_t' 0 - size Y - - 0 - p", (char*)NULL, (void*) G__func2void( (void (*)(size_t, void*))(&TStorage::EnterStat) ), 0);
   G__memfunc_setup("RemoveStat",1034,G__G__Base2_73_0_17, 121, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - p", (char*)NULL, (void*) G__func2void( (void (*)(void*))(&TStorage::RemoveStat) ), 0);
   G__memfunc_setup("PrintStatistics",1592,G__G__Base2_73_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStorage::PrintStatistics) ), 0);
   G__memfunc_setup("SetMaxBlockSize",1496,G__G__Base2_73_0_19, 121, -1, -1, 0, 1, 3, 1, 0, "h - 'size_t' 0 - size", (char*)NULL, (void*) G__func2void( (void (*)(size_t))(&TStorage::SetMaxBlockSize) ), 0);
   G__memfunc_setup("SetFreeHook",1087,G__G__Base2_73_0_20, 121, -1, -1, 0, 2, 3, 1, 0, 
"Y - 'FreeHookFun_t' 0 - func Y - - 0 - data", (char*)NULL, (void*) G__func2void( (void (*)(FreeHookFun_t, void*))(&TStorage::SetFreeHook) ), 0);
   G__memfunc_setup("SetReAllocHooks",1490,G__G__Base2_73_0_21, 121, -1, -1, 0, 2, 3, 1, 0, 
"Y - 'ReAllocFun_t' 0 - func1 Y - 'ReAllocCFun_t' 0 - func2", (char*)NULL, (void*) G__func2void( (void (*)(ReAllocFun_t, ReAllocCFun_t))(&TStorage::SetReAllocHooks) ), 0);
   G__memfunc_setup("SetCustomNewDelete",1828,G__G__Base2_73_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStorage::SetCustomNewDelete) ), 0);
   G__memfunc_setup("EnableStatistics",1650,G__G__Base2_73_0_23, 121, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 '-1' size i - - 0 '-1' ix", (char*)NULL, (void*) G__func2void( (void (*)(int, int))(&TStorage::EnableStatistics) ), 0);
   G__memfunc_setup("HasCustomNewDelete",1812,G__G__Base2_73_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TStorage::HasCustomNewDelete) ), 0);
   G__memfunc_setup("AddToHeap",842,G__G__Base2_73_0_25, 121, -1, -1, 0, 2, 3, 1, 0, 
"k - 'ULong_t' 0 - begin k - 'ULong_t' 0 - end", (char*)NULL, (void*) G__func2void( (void (*)(ULong_t, ULong_t))(&TStorage::AddToHeap) ), 0);
   G__memfunc_setup("IsOnHeap",759,G__G__Base2_73_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "Y - - 0 - p", (char*)NULL, (void*) G__func2void( (Bool_t (*)(void*))(&TStorage::IsOnHeap) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_73_0_27, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStorage::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_73_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStorage::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_73_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStorage::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_73_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStorage::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_73_0_31, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_73_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_73_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_73_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_73_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStorage::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_73_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStorage::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_73_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStorage::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_73_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStorage::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TStorage", 809, G__G__Base2_73_0_39, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStorage), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TStorage", 809, G__G__Base2_73_0_40, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStorage), -1, 0, 1, 1, 1, 0, "u 'TStorage' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TStorage", 935, G__G__Base2_73_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_73_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TStorage), -1, 1, 1, 1, 1, 0, "u 'TStorage' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTimer(void) {
   /* TTimer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TTimer));
   G__memfunc_setup("TTimer",597,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TTimer), -1, 0, 1, 1, 4, 0, "u 'TTimer' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TTimer), -1, 1, 1, 1, 4, 0, "u 'TTimer' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TTimer",597,G__G__Base2_80_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TTimer), -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 '0' milliSec g - 'Bool_t' 0 'kTRUE' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTimer",597,G__G__Base2_80_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TTimer), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj l - 'Long_t' 0 - milliSec "
"g - 'Bool_t' 0 'kTRUE' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTimer",597,G__G__Base2_80_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TTimer), -1, 0, 3, 1, 1, 0, 
"C - - 10 - command l - 'Long_t' 0 - milliSec "
"g - 'Bool_t' 0 'kTRUE' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckTimer",991,G__G__Base2_80_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TTime' - 11 - now", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCommand",991,G__G__Base2_80_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Base2_80_0_8, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__G__Base2_80_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimerID",942,G__G__Base2_80_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAbsTime",965,G__G__Base2_80_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasTimedOut",1095,G__G__Base2_80_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSync",601,G__G__Base2_80_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAsync",698,G__G__Base2_80_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInterruptingSyscalls",2325,G__G__Base2_80_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Base2_80_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCommand",1003,G__G__Base2_80_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - command", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetObject",899,G__G__Base2_80_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInterruptSyscalls",2119,G__G__Base2_80_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__G__Base2_80_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - milliSec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimerID",954,G__G__Base2_80_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '0' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Start",526,G__G__Base2_80_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 '-1' milliSec g - 'Bool_t' 0 'kFALSE' singleShot", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stop",422,G__G__Base2_80_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TurnOn",614,G__G__Base2_80_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("TurnOff",708,G__G__Base2_80_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Timeout",743,G__G__Base2_80_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("SingleShot",1024,G__G__Base2_80_0_30, 121, -1, -1, 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - milliSec C - - 10 - receiver_class "
"Y - - 0 - receiver C - - 10 - method", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, const char*, void*, const char*))(&TTimer::SingleShot) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_80_0_31, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTimer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_80_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTimer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_80_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTimer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_80_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTimer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_80_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_80_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTimer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_80_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTimer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_80_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTimer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_80_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTimer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTimer", 723, G__G__Base2_80_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProcessID(void) {
   /* TProcessID */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessID));
   G__memfunc_setup("TProcessID",960,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 1, 1, 4, 0, "u 'TProcessID' - 11 - ref", "TProcessID are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 1, 1, 1, 4, 0, "u 'TProcessID' - 11 - ref", "TProcessID are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("TProcessID",960,G__G__Base2_86_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckInit",882,G__G__Base2_86_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DecrementCount",1440,G__G__Base2_86_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementCount",1454,G__G__Base2_86_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__G__Base2_86_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjects",1002,G__G__Base2_86_0_9, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectWithID",1440,G__G__Base2_86_0_10, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PutObjectWithID",1465,G__G__Base2_86_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 '0' uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddProcessID",1141,G__G__Base2_86_0_13, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TProcessID* (*)())(&TProcessID::AddProcessID) ), 0);
   G__memfunc_setup("AssignID",754,G__G__Base2_86_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 1, 3, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) G__func2void( (UInt_t (*)(TObject*))(&TProcessID::AssignID) ), 0);
   G__memfunc_setup("Cleanup",712,G__G__Base2_86_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProcessID::Cleanup) ), 0);
   G__memfunc_setup("GetNProcessIDs",1357,G__G__Base2_86_0_16, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TProcessID::GetNProcessIDs) ), 0);
   G__memfunc_setup("GetPID",509,G__G__Base2_86_0_17, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TProcessID* (*)())(&TProcessID::GetPID) ), 0);
   G__memfunc_setup("GetPIDs",624,G__G__Base2_86_0_18, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjArray), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObjArray* (*)())(&TProcessID::GetPIDs) ), 0);
   G__memfunc_setup("GetProcessID",1164,G__G__Base2_86_0_19, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 1, 3, 1, 0, "r - 'UShort_t' 0 - pid", (char*)NULL, (void*) G__func2void( (TProcessID* (*)(UShort_t))(&TProcessID::GetProcessID) ), 0);
   G__memfunc_setup("GetProcessWithUID",1661,G__G__Base2_86_0_20, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 1, 3, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) G__func2void( (TProcessID* (*)(const TObject*))(&TProcessID::GetProcessWithUID) ), 0);
   G__memfunc_setup("GetProcessWithUID",1661,G__G__Base2_86_0_21, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 2, 3, 1, 0, 
"h - 'UInt_t' 0 - uid Y - - 10 - obj", (char*)NULL, (void*) G__func2void( (TProcessID* (*)(UInt_t, const void*))(&TProcessID::GetProcessWithUID) ), 0);
   G__memfunc_setup("GetSessionProcessID",1904,G__G__Base2_86_0_22, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TProcessID* (*)())(&TProcessID::GetSessionProcessID) ), 0);
   G__memfunc_setup("GetObjectCount",1408,G__G__Base2_86_0_23, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TProcessID::GetObjectCount) ), 0);
   G__memfunc_setup("IsValid",684,G__G__Base2_86_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "U 'TProcessID' - 0 - pid", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TProcessID*))(&TProcessID::IsValid) ), 0);
   G__memfunc_setup("SetObjectCount",1420,G__G__Base2_86_0_25, 121, -1, -1, 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - number", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t))(&TProcessID::SetObjectCount) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_86_0_26, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProcessID::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_86_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessID::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_86_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProcessID::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_86_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProcessID::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_86_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_86_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessID::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_86_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProcessID::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_86_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessID::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_86_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProcessID::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProcessID", 1086, G__G__Base2_86_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRefCnt(void) {
   /* TRefCnt */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TRefCnt));
   G__memfunc_setup("TRefCnt",662,G__G__Base2_99_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TRefCnt), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' initRef", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefCnt",662,G__G__Base2_99_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TRefCnt), -1, 0, 1, 1, 1, 0, "i 'TRefCnt::EReferenceFlag' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("References",1026,G__G__Base2_99_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRefCount",1106,G__G__Base2_99_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddReference",1176,G__G__Base2_99_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveReference",1533,G__G__Base2_99_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TRefCnt", 662, G__G__Base2_99_0_7, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TRefCnt), -1, 0, 1, 1, 1, 0, "u 'TRefCnt' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRefCnt", 788, G__G__Base2_99_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_99_0_9, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TRefCnt), -1, 1, 1, 1, 1, 0, "u 'TRefCnt' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRegexp(void) {
   /* TRegexp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TRegexp));
   G__memfunc_setup("CopyPattern",1145,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TRegexp' - 11 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenPattern",1016,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeWildcard",1192,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 4, 1, "C - - 10 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRegexp",703,G__G__Base2_102_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TRegexp), -1, 0, 2, 1, 1, 0, 
"C - - 10 - re g - 'Bool_t' 0 'kFALSE' wildcard", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRegexp",703,G__G__Base2_102_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TRegexp), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRegexp",703,G__G__Base2_102_0_6, 105, G__get_linked_tagnum(&G__G__Base2LN_TRegexp), -1, 0, 1, 1, 1, 0, "u 'TRegexp' - 11 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_102_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_TRegexp), -1, 1, 1, 1, 1, 0, "u 'TRegexp' - 11 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_102_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_TRegexp), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - re", "Recompiles pattern", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_102_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_TRegexp), -1, 1, 1, 1, 1, 0, "C - - 10 - re", "Recompiles pattern", (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Base2_102_0_10, 105, -1, G__defined_typename("Ssiz_t"), 0, 3, 1, 1, 8, 
"u 'TString' - 11 - str I - 'Ssiz_t' 0 - len "
"i - 'Ssiz_t' 0 '0' start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Status",644,G__G__Base2_102_0_11, 105, G__get_linked_tagnum(&G__G__Base2LN_TRegexpcLcLEStatVal), -1, 0, 0, 1, 1, 0, "", "Return & clear status", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_102_0_12, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRegexp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_102_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRegexp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_102_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRegexp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_102_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRegexp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_102_0_16, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_102_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_102_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_102_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_102_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRegexp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_102_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRegexp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_102_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRegexp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_102_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRegexp::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRegexp", 829, G__G__Base2_102_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPRegexp(void) {
   /* TPRegexp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TPRegexp));
   G__memfunc_setup("Compile",713,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Optimize",849,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseMods",910,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 2, 8, "u 'TString' - 11 - mods", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReplaceSubs",1113,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 8, 
"u 'TString' - 11 - s u 'TString' - 1 - final "
"u 'TString' - 11 - replacePattern I - 'Int_t' 0 - ovec "
"i - 'Int_t' 0 - nmatch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchInternal",1322,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"u 'TString' - 11 - s i - 'Int_t' 0 - start "
"i - 'Int_t' 0 - nMaxMatch U 'TArrayI' - 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SubstituteInternal",1913,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"u 'TString' - 1 - s u 'TString' - 11 - replace "
"i - 'Int_t' 0 - start i - 'Int_t' 0 - nMaxMatch0 "
"g - 'Bool_t' 0 - doDollarSubst", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPRegexp",783,G__G__Base2_103_0_7, 105, G__get_linked_tagnum(&G__G__Base2LN_TPRegexp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPRegexp",783,G__G__Base2_103_0_8, 105, G__get_linked_tagnum(&G__G__Base2LN_TPRegexp), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - pat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPRegexp",783,G__G__Base2_103_0_9, 105, G__get_linked_tagnum(&G__G__Base2LN_TPRegexp), -1, 0, 1, 1, 1, 0, "u 'TPRegexp' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Match",493,G__G__Base2_103_0_10, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TString' - 11 - s u 'TString' - 11 '\"\"' mods "
"i - 'Int_t' 0 '0' start i - 'Int_t' 0 '10' nMaxMatch "
"U 'TArrayI' - 0 '0' pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchS",576,G__G__Base2_103_0_11, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjArray), -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - s u 'TString' - 11 '\"\"' mods "
"i - 'Int_t' 0 '0' start i - 'Int_t' 0 '10' nMaxMatch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchB",559,G__G__Base2_103_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TString' - 11 - s u 'TString' - 11 '\"\"' mods "
"i - 'Int_t' 0 '0' start i - 'Int_t' 0 '10' nMaxMatch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Substitute",1084,G__G__Base2_103_0_13, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'TString' - 1 - s u 'TString' - 11 - replace "
"u 'TString' - 11 '\"\"' mods i - 'Int_t' 0 '0' start "
"i - 'Int_t' 0 '10' nMatchMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPattern",1022,G__G__Base2_103_0_14, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetModifiers",1218,G__G__Base2_103_0_15, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_103_0_16, 117, G__get_linked_tagnum(&G__G__Base2LN_TPRegexp), -1, 1, 1, 1, 1, 0, "u 'TPRegexp' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_103_0_17, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPRegexp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_103_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPRegexp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_103_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPRegexp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_103_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPRegexp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_103_0_21, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_103_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_103_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_103_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_103_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPRegexp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_103_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPRegexp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_103_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPRegexp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_103_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPRegexp::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPRegexp", 909, G__G__Base2_103_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSubString(void) {
   /* TSubString */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TSubString));
   G__memfunc_setup("TSubString",1013,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 3, 1, 4, 0, 
"u 'TString' - 11 - s i - 'Ssiz_t' 0 - start "
"i - 'Ssiz_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SubStringError",1451,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"i - 'Ssiz_t' 0 - - i - 'Ssiz_t' 0 - - "
"i - 'Ssiz_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertElement",1340,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "i - 'Ssiz_t' 0 - i", "Verifies i is valid index", (void*) NULL, 0);
   G__memfunc_setup("TSubString",1013,G__G__Base2_104_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 0, 1, 1, 1, 0, "u 'TSubString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_104_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 1, 1, 1, 1, 0, "C - - 10 - s", "Assignment from a char*", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_104_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - s", "Assignment from a TString", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_104_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_TSubString), -1, 1, 1, 1, 1, 0, "u 'TSubString' - 11 - s", "Assignment from a TSubString", (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_104_0_8, 99, -1, -1, 1, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - i", "Index with optional bounds checking", (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_104_0_9, 99, -1, -1, 1, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - i", "Index with bounds checking", (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Base2_104_0_10, 99, -1, -1, 0, 1, 1, 1, 8, "i - 'Ssiz_t' 0 - i", "Index with optional bounds checking", (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_104_0_11, 99, -1, -1, 0, 1, 1, 1, 8, "i - 'Ssiz_t' 0 - i", "Index with bounds checking", (void*) NULL, 0);
   G__memfunc_setup("Data",378,G__G__Base2_104_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Length",610,G__G__Base2_104_0_13, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Start",526,G__G__Base2_104_0_14, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("String",631,G__G__Base2_104_0_15, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToLower",716,G__G__Base2_104_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", "Convert self to lower-case", (void*) NULL, 0);
   G__memfunc_setup("ToUpper",719,G__G__Base2_104_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", "Convert self to upper-case", (void*) NULL, 0);
   G__memfunc_setup("IsNull",599,G__G__Base2_104_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!",909,G__G__Base2_104_0_19, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSubString", 1139, G__G__Base2_104_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStringRef(void) {
   /* TStringRef */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringRef));
   G__memfunc_setup("UnLink",593,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "disconnect from a TStringRef, maybe delete it", (void*) NULL, 0);
   G__memfunc_setup("Length",610,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Ssiz_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Data",378,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,(G__InterfaceMethod) NULL, 99, -1, -1, 1, 1, 1, 4, 0, "i - 'Ssiz_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,(G__InterfaceMethod) NULL, 99, -1, -1, 0, 1, 1, 4, 8, "i - 'Ssiz_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 4, 8, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 4, 8, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HashFoldCase",1157,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Last",404,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Ssiz_t"), 0, 1, 1, 4, 8, "c - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRep",583,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Base2LN_TStringRef), -1, 0, 2, 3, 4, 0, 
"i - 'Ssiz_t' 0 - capac i - 'Ssiz_t' 0 - nchar", (char*)NULL, (void*) NULL, 0);
   // automatic default constructor
   G__memfunc_setup("TStringRef", 1000, G__G__Base2_106_0_13, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStringRef), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TStringRef", 1000, G__G__Base2_106_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStringRef), -1, 0, 1, 1, 1, 0, "u 'TStringRef' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TStringRef", 1126, G__G__Base2_106_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_106_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TStringRef), -1, 1, 1, 1, 1, 0, "u 'TStringRef' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStringLong(void) {
   /* TStringLong */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringLong));
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 0, 1, 1, 0, "", "Null string", (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 1, 1, 1, 0, "i - 'Ssiz_t' 0 - ic", "Suggested capacity", (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", "Copy constructor", (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 1, 1, 1, 0, "C - - 10 - s", "Copy to embedded null", (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 2, 1, 1, 0, 
"C - - 10 - s i - 'Ssiz_t' 0 - n", "Copy past any embedded nulls", (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_6, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 1, 1, 1, 0, "c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_7, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 2, 1, 1, 0, 
"c - - 0 - c i - 'Ssiz_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStringLong",1115,G__G__Base2_107_0_8, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 1, 1, 1, 0, "u 'TSubString' - 11 - sub", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBuffer",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_107_0_12, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStringLong::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_107_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStringLong::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_107_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStringLong::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_107_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStringLong::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_107_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_107_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStringLong::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_107_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStringLong::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_107_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStringLong::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_107_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStringLong::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TStringLong", 1115, G__G__Base2_107_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 0, 1, 1, 1, 0, "u 'TStringLong' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TStringLong", 1241, G__G__Base2_107_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_107_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TStringLong), -1, 1, 1, 1, 1, 0, "u 'TStringLong' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQConnection(void) {
   /* TQConnection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TQConnection));
   G__memfunc_setup("PrintCollectionHeader",2146,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TQConnection",1205,G__G__Base2_110_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TQConnection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQConnection",1205,G__G__Base2_110_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TQConnection), -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl Y - - 0 - receiver "
"C - - 10 - method_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQConnection",1205,G__G__Base2_110_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TQConnection), -1, 0, 3, 1, 1, 0, 
"C - - 10 - class_name Y - - 0 - receiver "
"C - - 10 - method_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQConnection",1205,G__G__Base2_110_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TQConnection), -1, 0, 1, 1, 1, 0, "u 'TQConnection' - 11 - con", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReceiver",1109,G__G__Base2_110_0_7, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassName",1175,G__G__Base2_110_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Destroyed",947,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nargs u 'va_list' - 0 - va", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 0 - params i - 'Int_t' 0 '-1' nparam", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteMethod",1332,G__G__Base2_110_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_110_0_18, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQConnection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_110_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQConnection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_110_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQConnection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_110_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQConnection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_110_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_110_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQConnection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_110_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQConnection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_110_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQConnection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_110_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQConnection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TQConnection", 1331, G__G__Base2_110_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQObject(void) {
   /* TQObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TQObject));
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSenderClassName",1784,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConnectToClass",1411,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 2, 0, 
"U 'TQObject' - 0 - sender C - - 10 - signal "
"U 'TClass' - 0 - receiver_class Y - - 0 - receiver "
"C - - 10 - slot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConnectToClass",1411,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 2, 0, 
"C - - 10 - sender_class C - - 10 - signal "
"U 'TClass' - 0 - receiver_class Y - - 0 - receiver "
"C - - 10 - slot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckConnectArgs",1589,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 3, 2, 0, 
"U 'TQObject' - 0 - sender U 'TClass' - 0 - sender_class "
"C - - 10 - signal U 'TClass' - 0 - receiver_class "
"C - - 10 - slot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQObject",764,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TQObject), -1, 0, 1, 1, 4, 0, "u 'TQObject' - 11 - tqo", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TQObject), -1, 1, 1, 1, 4, 0, "u 'TQObject' - 11 - tqo", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TQObject",764,G__G__Base2_111_0_8, 105, G__get_linked_tagnum(&G__G__Base2LN_TQObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfClassSignals",2104,G__G__Base2_111_0_9, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfSignals",1602,G__G__Base2_111_0_10, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfConnections",2036,G__G__Base2_111_0_11, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AreSignalsBlocked",1693,G__G__Base2_111_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BlockSignals",1212,G__G__Base2_111_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectClassSignalLists",2345,G__G__Base2_111_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TList' - 1 - list U 'TClass' - 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EmitVA",550,G__G__Base2_111_0_15, 121, -1, -1, 0, 2, 8, 1, 0, 
"C - - 10 - signal i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EmitVA",550,G__G__Base2_111_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - signal i - 'Int_t' 0 - nargs "
"u 'va_list' - 0 - va", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - signal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal L - 'Long_t' 0 - paramArr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal C - - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal d - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal l - 'Long_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal n - 'Long64_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal g - 'Bool_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal c - 'Char_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal b - 'UChar_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal s - 'Short_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal r - 'UShort_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal i - 'Int_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal h - 'UInt_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal k - 'ULong_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal m - 'ULong64_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Emit",399,G__G__Base2_111_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal f - 'Float_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Connect",714,G__G__Base2_111_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"C - - 10 - signal C - - 10 - receiver_class "
"Y - - 0 - receiver C - - 10 - slot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Disconnect",1034,G__G__Base2_111_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 '0' signal Y - - 0 '0' receiver "
"C - - 10 '0' slot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighPriority",1250,G__G__Base2_111_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal_name C - - 10 '0' slot_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowPriority",1172,G__G__Base2_111_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - signal_name C - - 10 '0' slot_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasConnection",1324,G__G__Base2_111_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - signal_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NumberOfSignals",1519,G__G__Base2_111_0_38, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NumberOfConnections",1953,G__G__Base2_111_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Connected",915,G__G__Base2_111_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Disconnected",1235,G__G__Base2_111_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destroyed",947,G__G__Base2_111_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ChangedBy",869,G__G__Base2_111_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - method", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Message",709,G__G__Base2_111_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - msg", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Connect",714,G__G__Base2_111_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 1, 0, 
"U 'TQObject' - 0 - sender C - - 10 - signal "
"C - - 10 - receiver_class Y - - 0 - receiver "
"C - - 10 - slot", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TQObject*, const char*, const char*, void*, const char*))(&TQObject::Connect) ), 0);
   G__memfunc_setup("Connect",714,G__G__Base2_111_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 1, 0, 
"C - - 10 - sender_class C - - 10 - signal "
"C - - 10 - receiver_class Y - - 0 - receiver "
"C - - 10 - slot", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*, const char*, const char*, void*, const char*))(&TQObject::Connect) ), 0);
   G__memfunc_setup("Disconnect",1034,G__G__Base2_111_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"U 'TQObject' - 0 - sender C - - 10 '0' signal "
"Y - - 0 '0' receiver C - - 10 '0' slot", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TQObject*, const char*, void*, const char*))(&TQObject::Disconnect) ), 0);
   G__memfunc_setup("Disconnect",1034,G__G__Base2_111_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"C - - 10 - class_name C - - 10 - signal "
"Y - - 0 '0' receiver C - - 10 '0' slot", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*, const char*, void*, const char*))(&TQObject::Disconnect) ), 0);
   G__memfunc_setup("AreAllSignalsBlocked",1974,G__G__Base2_111_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TQObject::AreAllSignalsBlocked) ), 0);
   G__memfunc_setup("BlockAllSignals",1493,G__G__Base2_111_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Bool_t))(&TQObject::BlockAllSignals) ), 0);
   G__memfunc_setup("LoadRQ_OBJECT",1081,G__G__Base2_111_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQObject::LoadRQ_OBJECT) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_111_0_52, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_111_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_111_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_111_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_111_0_56, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_111_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_111_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_111_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_111_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_111_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_111_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_111_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQObject::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TQObject", 890, G__G__Base2_111_0_64, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQObjSender(void) {
   /* TQObjSender */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TQObjSender));
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSenderClassName",1784,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TQObjSender",1057,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TQObjSender), -1, 0, 1, 1, 4, 0, "u 'TQObjSender' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TQObjSender), -1, 1, 1, 1, 4, 0, "u 'TQObjSender' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TQObjSender",1057,G__G__Base2_112_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TQObjSender), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSender",909,G__G__Base2_112_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - sender", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSenderClassName",1796,G__G__Base2_112_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' sclass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_112_0_8, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQObjSender::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_112_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQObjSender::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_112_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQObjSender::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_112_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQObjSender::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_112_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_112_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQObjSender::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_112_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQObjSender::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_112_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQObjSender::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_112_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQObjSender::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TQObjSender", 1183, G__G__Base2_112_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSignalHandler(void) {
   /* TSignalHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler));
   G__memfunc_setup("TSignalHandler",1392,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSignalHandler",1392,G__G__Base2_115_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler), -1, 0, 2, 1, 1, 0, 
"i 'ESignals' - 0 - sig g - 'Bool_t' 0 'kTRUE' sync", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delay",495,G__G__Base2_115_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDelayedSignal",1890,G__G__Base2_115_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSignal",894,G__G__Base2_115_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_ESignals), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSignal",906,G__G__Base2_115_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ESignals' - 0 - sig", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSync",601,G__G__Base2_115_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAsync",698,G__G__Base2_115_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_115_0_12, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSignalHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_115_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSignalHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_115_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSignalHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_115_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSignalHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_115_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_115_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSignalHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_115_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSignalHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_115_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSignalHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_115_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSignalHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSignalHandler", 1518, G__G__Base2_115_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStopwatch(void) {
   /* TStopwatch */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TStopwatch));
   G__memfunc_setup("GetRealTime",1075,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCPUTime",919,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TStopwatch",1041,G__G__Base2_129_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TStopwatch), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Start",526,G__G__Base2_129_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' reset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Stop",422,G__G__Base2_129_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Continue",837,G__G__Base2_129_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Counter",736,G__G__Base2_129_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RealTime",787,G__G__Base2_129_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Base2_129_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetCpuTime",1210,G__G__Base2_129_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetRealTime",1302,G__G__Base2_129_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CpuTime",695,G__G__Base2_129_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_129_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStopwatch::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_129_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStopwatch::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_129_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStopwatch::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_129_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStopwatch::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_129_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_129_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStopwatch::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_129_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStopwatch::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_129_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStopwatch::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_129_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStopwatch::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TStopwatch", 1041, G__G__Base2_129_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStopwatch), -1, 0, 1, 1, 1, 0, "u 'TStopwatch' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TStopwatch", 1167, G__G__Base2_129_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_129_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TStopwatch), -1, 1, 1, 1, 1, 0, "u 'TStopwatch' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTUUID(void) {
   /* TUUID */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TUUID));
   G__memfunc_setup("CmpTime",687,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"U 'TUUID::uuid_time_t' - 0 - t1 U 'TUUID::uuid_time_t' - 0 - t2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Format",617,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"r - 'UShort_t' 0 - clockseq u 'TUUID::uuid_time_t' - 0 - ts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodeIdentifier",1705,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentTime",1426,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TUUID::uuid_time_t' - 0 - timestamp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSystemTime",1332,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TUUID::uuid_time_t' - 0 - timestamp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomInfo",1293,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "B - 'UChar_t' 0 - seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFromString",1335,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - uuid_str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TUUID",395,G__G__Base2_173_0_8, 105, G__get_linked_tagnum(&G__G__Base2LN_TUUID), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TUUID",395,G__G__Base2_173_0_9, 105, G__get_linked_tagnum(&G__G__Base2LN_TUUID), -1, 0, 1, 1, 1, 0, "C - - 10 - uuid_str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Base2_173_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Compare",711,G__G__Base2_173_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "u 'TUUID' - 11 - u", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hash",388,G__G__Base2_173_0_12, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Base2_173_0_13, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHostAddress",1412,G__G__Base2_173_0_14, 117, G__get_linked_tagnum(&G__G__Base2LN_TInetAddress), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__G__Base2_173_0_15, 117, G__get_linked_tagnum(&G__G__Base2LN_TDatime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUUID",599,G__G__Base2_173_0_16, 121, -1, -1, 0, 1, 1, 1, 8, "B - 'UChar_t' 0 - uuid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUUID",611,G__G__Base2_173_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - uuid_str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUUIDNumber",1216,G__G__Base2_173_0_18, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUUIDNumber",1228,G__G__Base2_173_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerV1",970,G__G__Base2_173_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBuffer",993,G__G__Base2_173_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBuffer",982,G__G__Base2_173_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof",624,G__G__Base2_173_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_173_0_24, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TUUID::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_173_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUUID::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_173_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TUUID::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_173_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TUUID::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_173_0_28, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_173_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_173_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_173_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_173_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUUID::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_173_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TUUID::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_173_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUUID::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_173_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TUUID::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TUUID", 395, G__G__Base2_173_0_36, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TUUID), -1, 0, 1, 1, 1, 0, "u 'TUUID' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TUUID", 521, G__G__Base2_173_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_173_0_38, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TUUID), -1, 1, 1, 1, 1, 0, "u 'TUUID' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTExec(void) {
   /* TExec */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TExec));
   G__memfunc_setup("TExec",473,G__G__Base2_187_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TExec), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TExec",473,G__G__Base2_187_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TExec), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - command", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TExec",473,G__G__Base2_187_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TExec), -1, 0, 1, 1, 1, 0, "u 'TExec' - 11 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Exec",389,G__G__Base2_187_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' command", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAction",906,G__G__Base2_187_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_187_0_8, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TExec::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_187_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExec::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_187_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TExec::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_187_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TExec::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_187_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_187_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExec::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_187_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExec::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_187_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExec::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_187_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExec::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TExec", 599, G__G__Base2_187_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_187_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TExec), -1, 1, 1, 1, 1, 0, "u 'TExec' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFolder(void) {
   /* TFolder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TFolder));
   G__memfunc_setup("TFolder",688,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TFolder), -1, 0, 1, 1, 4, 0, "u 'TFolder' - 11 - folder", "folders cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TFolder' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFolder",688,G__G__Base2_188_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TFolder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFolder",688,G__G__Base2_188_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TFolder), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Base2_188_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFolder",869,G__G__Base2_188_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TFolder), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TCollection' - 0 '0' collection", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFullPathName",1570,G__G__Base2_188_0_10, 67, -1, -1, 0, 1, 1, 1, 9, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFullPathName",1570,G__G__Base2_188_0_11, 67, -1, -1, 0, 1, 1, 1, 9, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObjectAny",1280,G__G__Base2_188_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfFolders",1600,G__G__Base2_188_0_15, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOwner",711,G__G__Base2_188_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Occurence",919,G__G__Base2_188_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Base2_188_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveAs",579,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"\"' filename C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetOwner",823,G__G__Base2_188_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' owner", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_188_0_24, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFolder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_188_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFolder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_188_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFolder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_188_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFolder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_188_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_188_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFolder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_188_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFolder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_188_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFolder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_188_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFolder::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFolder", 814, G__G__Base2_188_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObjString(void) {
   /* TObjString */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TObjString));
   G__memfunc_setup("TObjString",998,G__G__Base2_191_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TObjString), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjString",998,G__G__Base2_191_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TObjString), -1, 0, 1, 1, 1, 0, "u 'TObjString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,G__G__Base2_191_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEqual",692,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__Base2_191_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 1 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetString",931,G__G__Base2_191_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetString",919,G__G__Base2_191_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof",624,G__G__Base2_191_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("String",631,G__G__Base2_191_0_14, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_191_0_15, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TObjString::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_191_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjString::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_191_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TObjString::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_191_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TObjString::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_191_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_191_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjString::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_191_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjString::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_191_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjString::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_191_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjString::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TObjString", 1124, G__G__Base2_191_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_191_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TObjString), -1, 1, 1, 1, 1, 0, "u 'TObjString' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMD5(void) {
   /* TMD5 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TMD5));
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"H - 'UInt_t' 0 - buf B - 'UChar_t' 10 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Encode",590,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"B - 'UChar_t' 0 - out H - 'UInt_t' 10 - in "
"h - 'UInt_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Decode",580,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"H - 'UInt_t' 0 - out B - 'UChar_t' 10 - in "
"h - 'UInt_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMD5",282,G__G__Base2_192_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMD5",282,G__G__Base2_192_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 0, 1, 1, 1, 0, "B - 'UChar_t' 10 - digest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMD5",282,G__G__Base2_192_0_6, 105, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 0, 1, 1, 1, 0, "u 'TMD5' - 11 - md5", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_192_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 1, 1, 1, 1, 0, "u 'TMD5' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Base2_192_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - buf h - 'UInt_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Final",490,G__G__Base2_192_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Final",490,G__G__Base2_192_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "B - 'UChar_t' 0 - digest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Base2_192_0_11, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Base2_192_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDigest",908,G__G__Base2_192_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - md5ascii", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadChecksum",1199,G__G__Base2_192_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 0, 1, 3, 1, 0, "C - - 10 - file", (char*)NULL, (void*) G__func2void( (TMD5* (*)(const char*))(&TMD5::ReadChecksum) ), 0);
   G__memfunc_setup("WriteChecksum",1342,G__G__Base2_192_0_15, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"C - - 10 - file U 'TMD5' - 10 - md5", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*, const TMD5*))(&TMD5::WriteChecksum) ), 0);
   G__memfunc_setup("FileChecksum",1203,G__G__Base2_192_0_16, 85, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 0, 1, 3, 1, 0, "C - - 10 - file", (char*)NULL, (void*) G__func2void( (TMD5* (*)(const char*))(&TMD5::FileChecksum) ), 0);
   G__memfunc_setup("FileChecksum",1203,G__G__Base2_192_0_17, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"C - - 10 - file B - 'UChar_t' 0 - digest", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*, UChar_t*))(&TMD5::FileChecksum) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_192_0_18, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMD5::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_192_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMD5::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_192_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMD5::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_192_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMD5::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_192_0_22, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_192_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_192_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_192_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_192_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMD5::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_192_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMD5::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_192_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMD5::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_192_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMD5::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMD5", 408, G__G__Base2_192_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMacro(void) {
   /* TMacro */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TMacro));
   G__memfunc_setup("TMacro",582,G__G__Base2_193_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TMacro), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMacro",582,G__G__Base2_193_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TMacro), -1, 0, 1, 1, 1, 0, "u 'TMacro' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMacro",582,G__G__Base2_193_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TMacro), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_193_0_4, 117, G__get_linked_tagnum(&G__G__Base2LN_TMacro), -1, 1, 1, 1, 1, 0, "u 'TMacro' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLine",657,G__G__Base2_193_0_5, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjString), -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Checksum",819,G__G__Base2_193_0_7, 85, G__get_linked_tagnum(&G__G__Base2LN_TMD5), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineWith",1092,G__G__Base2_193_0_8, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjString), -1, 0, 1, 1, 1, 8, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Exec",389,G__G__Base2_193_0_9, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 '0' params I - 'Int_t' 0 '0' error", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetListOfLines",1388,G__G__Base2_193_0_10, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ReadFile",764,G__G__Base2_193_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveSource",1024,G__G__Base2_193_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - filename", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParams",912,G__G__Base2_193_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' params", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_193_0_17, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMacro::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_193_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMacro::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_193_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMacro::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_193_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMacro::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_193_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_193_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMacro::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_193_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMacro::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_193_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMacro::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_193_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMacro::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMacro", 708, G__G__Base2_193_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMessageHandler(void) {
   /* TMessageHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler));
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 2, 0, "", "used to set gTQSender", (void*) NULL, 1);
   G__memfunc_setup("TMessageHandler",1495,G__G__Base2_194_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler), -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl g - 'Bool_t' 0 'kTRUE' derived", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMessageHandler",1495,G__G__Base2_194_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TMessageHandler), -1, 0, 2, 1, 1, 0, 
"C - - 10 - cl g - 'Bool_t' 0 'kTRUE' derived", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Base2_194_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMessageCount",1518,G__G__Base2_194_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - messId", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTotalMessageCount",2034,G__G__Base2_194_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDerived",1295,G__G__Base2_194_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMessage",1297,G__G__Base2_194_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - id U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Base2_194_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Base2_194_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Added",466,G__G__Base2_194_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Removed",722,G__G__Base2_194_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Notified",818,G__G__Base2_194_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_194_0_16, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMessageHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_194_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessageHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_194_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMessageHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_194_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMessageHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_194_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_194_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessageHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_194_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMessageHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_194_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMessageHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_194_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMessageHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMessageHandler", 1621, G__G__Base2_194_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPluginManager(void) {
   /* TPluginManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TPluginManager));
   G__memfunc_setup("TPluginManager",1406,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TPluginManager), -1, 0, 1, 1, 4, 0, "u 'TPluginManager' - 11 - pm", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TPluginManager), -1, 1, 1, 1, 4, 0, "u 'TPluginManager' - 11 - pm", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("LoadHandlerMacros",1699,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPluginManager",1406,G__G__Base2_197_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TPluginManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadHandlersFromEnv",1902,G__G__Base2_197_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEnv' - 0 - env", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadHandlersFromPluginDirs",2630,G__G__Base2_197_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' base", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHandler",967,G__G__Base2_197_0_7, 121, -1, -1, 0, 6, 1, 1, 0, 
"C - - 10 - base C - - 10 - regexp "
"C - - 10 - className C - - 10 - pluginName "
"C - - 10 '0' ctor C - - 10 '0' origin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveHandler",1324,G__G__Base2_197_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - base C - - 10 '0' regexp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindHandler",1087,G__G__Base2_197_0_9, 85, G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler), -1, 0, 2, 1, 1, 0, 
"C - - 10 - base C - - 10 '0' uri", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WritePluginMacros",1759,G__G__Base2_197_0_11, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - dir C - - 10 '0' plugin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WritePluginRecords",1868,G__G__Base2_197_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - envFile C - - 10 '0' plugin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_197_0_13, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPluginManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_197_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPluginManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_197_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPluginManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_197_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPluginManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_197_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_197_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPluginManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_197_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPluginManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_197_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPluginManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_197_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPluginManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPluginManager", 1532, G__G__Base2_197_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPluginHandler(void) {
   /* TPluginHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler));
   G__memfunc_setup("TPluginHandler",1409,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPluginHandler",1409,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler), -1, 0, 6, 1, 4, 0, 
"C - - 10 - base C - - 10 - regexp "
"C - - 10 - className C - - 10 - pluginName "
"C - - 10 - ctor C - - 10 - origin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPluginHandler",1409,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler), -1, 0, 1, 1, 4, 0, "u 'TPluginHandler' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TPluginHandler), -1, 1, 1, 1, 4, 0, "u 'TPluginHandler' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetBase",667,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRegexp",907,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlugin",911,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCtor",696,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrigin",904,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanHandle",862,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"C - - 10 - base C - - 10 - uri", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupCallEnv",1206,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Base2_198_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckPlugin",1101,G__G__Base2_198_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadPlugin",1007,G__G__Base2_198_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecPlugin",1012,G__G__Base2_198_0_15, 108, -1, G__defined_typename("Long_t"), 0, 1, 8, 1, 0, "i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_198_0_17, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPluginHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_198_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPluginHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_198_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPluginHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_198_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPluginHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_198_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_198_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPluginHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_198_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPluginHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_198_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPluginHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_198_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPluginHandler::DeclFileLine) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPoint(void) {
   /* TPoint */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TPoint));
   G__memfunc_setup("TPoint",606,G__G__Base2_199_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TPoint), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoint",606,G__G__Base2_199_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TPoint), -1, 0, 1, 1, 1, 0, "s - 'SCoord_t' 0 - xy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPoint",606,G__G__Base2_199_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TPoint), -1, 0, 2, 1, 1, 0, 
"s - 'SCoord_t' 0 - x s - 'SCoord_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Base2_199_0_4, 115, -1, G__defined_typename("SCoord_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Base2_199_0_5, 115, -1, G__defined_typename("SCoord_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__G__Base2_199_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'SCoord_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__G__Base2_199_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'SCoord_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_199_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_TPoint), -1, 1, 1, 1, 1, 0, "u 'TPoint' - 11 - p", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TPoint", 606, G__G__Base2_199_0_9, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TPoint), -1, 0, 1, 1, 1, 0, "u 'TPoint' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TPoint", 732, G__G__Base2_199_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPMERegexp(void) {
   /* TPMERegexp */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp), -1, 1, 1, 1, 4, 0, "u 'TPMERegexp' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TPMERegexp",929,G__G__Base2_202_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPMERegexp",929,G__G__Base2_202_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - s u 'TString' - 11 '\"\"' opts "
"i - 'Int_t' 0 '10' nMatchMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPMERegexp",929,G__G__Base2_202_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - s h - 'UInt_t' 0 - opts "
"i - 'Int_t' 0 '10' nMatchMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPMERegexp",929,G__G__Base2_202_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TPMERegexp), -1, 0, 1, 1, 1, 0, "u 'TPMERegexp' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Base2_202_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - s u 'TString' - 11 '\"\"' opts "
"i - 'Int_t' 0 '-1' nMatchMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Base2_202_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - s h - 'UInt_t' 0 - opts "
"i - 'Int_t' 0 '-1' nMatchMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNMaxMatches",1369,G__G__Base2_202_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNMaxMatches",1381,G__G__Base2_202_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalPosition",1734,G__G__Base2_202_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssignGlobalState",1719,G__G__Base2_202_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TPMERegexp' - 11 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetGlobalState",1621,G__G__Base2_202_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Match",493,G__G__Base2_202_0_13, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s h - 'UInt_t' 0 '0' start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Split",524,G__G__Base2_202_0_14, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s i - 'Int_t' 0 '0' maxfields", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Substitute",1084,G__G__Base2_202_0_15, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 1 - s u 'TString' - 11 - r "
"g - 'Bool_t' 0 'kTRUE' doDollarSubst", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NMatches",787,G__G__Base2_202_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_202_0_17, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Base2_202_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_202_0_19, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPMERegexp::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_202_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPMERegexp::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_202_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPMERegexp::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_202_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPMERegexp::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_202_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_202_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPMERegexp::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_202_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPMERegexp::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_202_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPMERegexp::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_202_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPMERegexp::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPMERegexp", 1055, G__G__Base2_202_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStringToken(void) {
   /* TStringToken */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TStringToken));
   G__memfunc_setup("TStringToken",1228,G__G__Base2_203_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TStringToken), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - fullStr u 'TString' - 11 - splitRe "
"g - 'Bool_t' 0 'kFALSE' retVoid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextToken",928,G__G__Base2_203_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AtEnd",460,G__G__Base2_203_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_203_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStringToken::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_203_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStringToken::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_203_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStringToken::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_203_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStringToken::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_203_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_203_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStringToken::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_203_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStringToken::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_203_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStringToken::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_203_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStringToken::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TStringToken", 1228, G__G__Base2_203_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TStringToken), -1, 0, 1, 1, 1, 0, "u 'TStringToken' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TStringToken", 1354, G__G__Base2_203_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProcessUUID(void) {
   /* TProcessUUID */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID));
   G__memfunc_setup("TProcessUUID",1130,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID), -1, 0, 1, 1, 4, 0, "u 'TProcessID' - 11 - -", "TProcessUUID are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID), -1, 1, 1, 1, 4, 0, "u 'TProcessUUID' - 11 - -", "TProcessUUID are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("TProcessUUID",1130,G__G__Base2_207_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddUUID",576,G__G__Base2_207_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"u 'TUUID' - 1 - uuid U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddUUID",576,G__G__Base2_207_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "C - - 10 - uuids", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindUUID",696,G__G__Base2_207_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjString), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActive",892,G__G__Base2_207_0_7, 85, G__get_linked_tagnum(&G__G__Base2LN_TBits), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUUIDs",714,G__G__Base2_207_0_8, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveUUID",933,G__G__Base2_207_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_207_0_10, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProcessUUID::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_207_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessUUID::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_207_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProcessUUID::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_207_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProcessUUID::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_207_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_207_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessUUID::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_207_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProcessUUID::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_207_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessUUID::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_207_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProcessUUID::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProcessUUID", 1256, G__G__Base2_207_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQClass(void) {
   /* TQClass */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TQClass));
   G__memfunc_setup("TQClass",667,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TQClass), -1, 0, 1, 1, 4, 0, "u 'TClass' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TQClass), -1, 1, 1, 1, 4, 0, "u 'TQClass' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQClass",667,G__G__Base2_231_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TQClass), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name s - 'Version_t' 0 - cversion "
"u 'type_info' - 11 - info U 'TVirtualIsAProxy' - 0 - isa "
"Y - 'ShowMembersFunc_t' 0 - showmembers C - - 10 '0' dfil "
"C - - 10 '0' ifil i - 'Int_t' 0 '0' dl "
"i - 'Int_t' 0 '0' il", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_231_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQClass::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_231_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQClass::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_231_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQClass::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_231_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQClass::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_231_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_231_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQClass::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_231_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQClass::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_231_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQClass::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_231_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQClass::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TQClass", 793, G__G__Base2_231_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQCommand(void) {
   /* TQCommand */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TQCommand));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"C - - 10 - cl Y - - 0 - object "
"C - - 10 - redo C - - 10 - undo", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintCollectionHeader",2146,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TQCommand",868,G__G__Base2_233_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TQCommand), -1, 0, 4, 1, 1, 0, 
"C - - 10 '0' cl Y - - 0 '0' object "
"C - - 10 '0' redo C - - 10 '0' undo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQCommand",868,G__G__Base2_233_0_4, 105, G__get_linked_tagnum(&G__G__Base2LN_TQCommand), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 '0' redo "
"C - - 10 '0' undo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TQCommand",868,G__G__Base2_233_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TQCommand), -1, 0, 1, 1, 1, 0, "u 'TQCommand' - 11 - com", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Redo",394,G__G__Base2_233_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Undo",406,G__G__Base2_233_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("SetArgs",697,G__G__Base2_233_0_8, 121, -1, -1, 0, 1, 8, 1, 0, "i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUndoArgs",1103,G__G__Base2_233_0_9, 121, -1, -1, 0, 1, 8, 1, 0, "i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRedoArgs",1091,G__G__Base2_233_0_10, 121, -1, -1, 0, 1, 8, 1, 0, "i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanMerge",770,G__G__Base2_233_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TQCommand' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Base2_233_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQCommand' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanCompress",1118,G__G__Base2_233_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TQCommand' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compress",844,G__G__Base2_233_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQCommand' - 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEqual",692,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSetter",819,G__G__Base2_233_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanRedo",668,G__G__Base2_233_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanUndo",680,G__G__Base2_233_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRedoName",1067,G__G__Base2_233_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUndoName",1079,G__G__Base2_233_0_20, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRedo",682,G__G__Base2_233_0_21, 85, G__get_linked_tagnum(&G__G__Base2LN_TQConnection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUndo",694,G__G__Base2_233_0_22, 85, G__get_linked_tagnum(&G__G__Base2LN_TQConnection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRedoArgs",1079,G__G__Base2_233_0_23, 76, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUndoArgs",1091,G__G__Base2_233_0_24, 76, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNRargs",877,G__G__Base2_233_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNUargs",880,G__G__Base2_233_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Base2_233_0_27, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__G__Base2_233_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMacro",686,G__G__Base2_233_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsUndoing",912,G__G__Base2_233_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRedoing",900,G__G__Base2_233_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsExecuting",1128,G__G__Base2_233_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Base2_233_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCommand",991,G__G__Base2_233_0_41, 85, G__get_linked_tagnum(&G__G__Base2LN_TQCommand), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TQCommand* (*)())(&TQCommand::GetCommand) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_233_0_42, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQCommand::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_233_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQCommand::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_233_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQCommand::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_233_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQCommand::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_233_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_233_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQCommand::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_233_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQCommand::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_233_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQCommand::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_233_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQCommand::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TQCommand", 994, G__G__Base2_233_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQUndoManager(void) {
   /* TQUndoManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager));
   G__memfunc_setup("PrintCollectionEntry",2091,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"U 'TObject' - 0 - entry C - 'Option_t' 10 - option "
"i - 'Int_t' 0 - recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TQUndoManager",1270,G__G__Base2_234_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TQUndoManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Redo",394,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Undo",406,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanRedo",668,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanUndo",680,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLogging",1011,G__G__Base2_234_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLogging",899,G__G__Base2_234_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrent",1027,G__G__Base2_234_0_11, 85, G__get_linked_tagnum(&G__G__Base2LN_TQCommand), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCursor",926,G__G__Base2_234_0_12, 85, G__get_linked_tagnum(&G__G__Base2LN_TQCommand), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimit",799,G__G__Base2_234_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimit",811,G__G__Base2_234_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - limit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CurrentChanged",1421,G__G__Base2_234_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQCommand' - 0 - c", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_234_0_17, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQUndoManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_234_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQUndoManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_234_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQUndoManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_234_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQUndoManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_234_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_234_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQUndoManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_234_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQUndoManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_234_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQUndoManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_234_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQUndoManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TQUndoManager", 1396, G__G__Base2_234_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRef(void) {
   /* TRef */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TRef));
   G__memfunc_setup("TRef",369,G__G__Base2_236_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TRef), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRef",369,G__G__Base2_236_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TRef), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRef",369,G__G__Base2_236_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TRef), -1, 0, 1, 1, 1, 0, "u 'TRef' - 11 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_236_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_236_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_TRef), -1, 1, 1, 1, 1, 0, "u 'TRef' - 11 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Base2_236_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPID",509,G__G__Base2_236_0_7, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessID), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Base2_236_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAction",906,G__G__Base2_236_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAction",906,G__G__Base2_236_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Base2_236_0_11, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) G__func2void( (void (*)(TObject*))(&TRef::SetObject) ), 0);
   G__memfunc_setup("SetStaticObject",1515,G__G__Base2_236_0_12, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) G__func2void( (void (*)(TObject*))(&TRef::SetStaticObject) ), 0);
   G__memfunc_setup("AddExec",654,G__G__Base2_236_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*))(&TRef::AddExec) ), 0);
   G__memfunc_setup("GetListOfExecs",1385,G__G__Base2_236_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TObjArray), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObjArray* (*)())(&TRef::GetListOfExecs) ), 0);
   G__memfunc_setup("GetStaticObject",1503,G__G__Base2_236_0_15, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObject* (*)())(&TRef::GetStaticObject) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_236_0_16, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRef::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_236_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRef::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_236_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRef::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_236_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRef::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_236_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_236_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRef::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_236_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRef::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_236_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRef::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_236_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRef::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRef", 495, G__G__Base2_236_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSystemFile(void) {
   /* TSystemFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemFile));
   G__memfunc_setup("TSystemFile",1113,G__G__Base2_239_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystemFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSystemFile",1113,G__G__Base2_239_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystemFile), -1, 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 10 - dirname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rename",600,G__G__Base2_239_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Delete",595,G__G__Base2_239_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Copy",411,G__G__Base2_239_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - to", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Move",407,G__G__Base2_239_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - to", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Edit",390,G__G__Base2_239_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("IsDirectory",1137,G__G__Base2_239_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 '0' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIconName",1078,G__G__Base2_239_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Inspect",726,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dump",406,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawClass",900,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawClone",895,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_239_0_21, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSystemFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_239_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystemFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_239_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSystemFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_239_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSystemFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_239_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_239_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystemFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_239_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSystemFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_239_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystemFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_239_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSystemFile::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSystemFile", 1113, G__G__Base2_239_0_33, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TSystemFile), -1, 0, 1, 1, 1, 0, "u 'TSystemFile' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSystemFile", 1239, G__G__Base2_239_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_239_0_35, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TSystemFile), -1, 1, 1, 1, 1, 0, "u 'TSystemFile' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSystemDirectory(void) {
   /* TSystemDirectory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory));
   G__memfunc_setup("IsItDirectory",1326,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindDirObj",955,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory), -1, 0, 1, 1, 2, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindFileObj",1052,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Base2LN_TSystemFile), -1, 0, 2, 1, 2, 0, 
"C - - 10 - name C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSystemDirectory",1678,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory), -1, 0, 1, 1, 2, 0, "u 'TSystemDirectory' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory), -1, 1, 1, 1, 2, 0, "u 'TSystemDirectory' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSystemDirectory",1678,G__G__Base2_241_0_6, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSystemDirectory",1678,G__G__Base2_241_0_7, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystemDirectory), -1, 0, 2, 1, 1, 0, 
"C - - 10 - dirname C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDirectory",1137,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Edit",390,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfFiles",1380,G__G__Base2_241_0_12, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectory",1249,G__G__Base2_241_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Move",407,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawClass",900,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawClone",895,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_241_0_24, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSystemDirectory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_241_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystemDirectory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_241_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSystemDirectory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_241_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSystemDirectory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_241_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_241_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystemDirectory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_241_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSystemDirectory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_241_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystemDirectory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_241_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSystemDirectory::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSystemDirectory", 1804, G__G__Base2_241_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSystem(void) {
   /* TSystem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TSystem));
   G__memfunc_setup("FindHelper",993,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Base2LN_TSystem), -1, 0, 2, 1, 2, 0, 
"C - - 10 - path Y - - 0 '0' dirptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConsistentWith",1478,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"C - - 10 - path Y - - 0 '0' dirptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandFileName",1377,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 2, 1, "C - - 10 - fname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SigAlarmInterruptsSyscalls",2718,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLinkedLibraries",1812,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 2, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoBeep",559,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"i - 'Int_t' 0 '-1' - i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StripOffProto",1345,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 2, 3, 2, 1, 
"C - - 10 - path C - - 10 - proto", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSystem",729,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystem), -1, 0, 1, 1, 4, 0, "u 'TSystem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TSystem), -1, 1, 1, 1, 4, 0, "u 'TSystem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TSystem",729,G__G__Base2_242_0_10, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystem), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"Generic\"' name C - - 10 '\"Generic System\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__Base2_242_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProgname",1125,G__G__Base2_242_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDisplay",1026,G__G__Base2_242_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetErrorStr",1135,G__G__Base2_242_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - errstr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorStr",1123,G__G__Base2_242_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__G__Base2_242_0_16, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveOnExit",1221,G__G__Base2_242_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HostName",799,G__G__Base2_242_0_18, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NotifyApplicationCreated",2469,G__G__Base2_242_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrno",806,G__G__Base2_242_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TSystem::GetErrno) ), 0);
   G__memfunc_setup("ResetErrno",1033,G__G__Base2_242_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSystem::ResetErrno) ), 0);
   G__memfunc_setup("Beep",380,G__G__Base2_242_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '-1' freq i - 'Int_t' 0 '-1' duration "
"g - 'Bool_t' 0 'kFALSE' setDefault", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBeepDefaults",1492,G__G__Base2_242_0_23, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 1 - freq i - 'Int_t' 1 - duration", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,G__G__Base2_242_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvents",1364,G__G__Base2_242_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DispatchOneEvent",1620,G__G__Base2_242_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' pendingOnly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExitLoop",820,G__G__Base2_242_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InControl",920,G__G__Base2_242_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InnerLoop",918,G__G__Base2_242_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Base2_242_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TList' - 0 - active l - 'Long_t' 0 - timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Base2_242_0_31, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TFileHandler' - 0 - fh l - 'Long_t' 0 - timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddSignalHandler",1573,G__G__Base2_242_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSignalHandler' - 0 - sh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveSignalHandler",1930,G__G__Base2_242_0_33, 85, G__get_linked_tagnum(&G__G__Base2LN_TSignalHandler), -1, 0, 1, 1, 1, 0, "U 'TSignalHandler' - 0 - sh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetSignal",1121,G__G__Base2_242_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'ESignals' - 0 - sig g - 'Bool_t' 0 'kTRUE' reset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreSignal",1218,G__G__Base2_242_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'ESignals' - 0 - sig g - 'Bool_t' 0 'kTRUE' ignore", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreInterrupt",1585,G__G__Base2_242_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ignore", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfSignalHandlers",2304,G__G__Base2_242_0_37, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFileHandler",1351,G__G__Base2_242_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFileHandler' - 0 - fh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFileHandler",1708,G__G__Base2_242_0_39, 85, G__get_linked_tagnum(&G__G__Base2LN_TFileHandler), -1, 0, 1, 1, 1, 0, "U 'TFileHandler' - 0 - fh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfFileHandlers",2082,G__G__Base2_242_0_40, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddStdExceptionHandler",2209,G__G__Base2_242_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TStdExceptionHandler' - 0 - eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveStdExceptionHandler",2566,G__G__Base2_242_0_42, 85, G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler), -1, 0, 1, 1, 1, 0, "U 'TStdExceptionHandler' - 0 - eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfStdExceptionHandlers",2940,G__G__Base2_242_0_43, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFPEMask",903,G__G__Base2_242_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFPEMask",915,G__G__Base2_242_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kDefaultMask' mask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Now",308,G__G__Base2_242_0_46, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfTimers",1509,G__G__Base2_242_0_47, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTimer",778,G__G__Base2_242_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveTimer",1135,G__G__Base2_242_0_49, 85, G__get_linked_tagnum(&G__G__Base2LN_TTimer), -1, 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetTimer",1028,G__G__Base2_242_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTimer' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextTimeOut",1126,G__G__Base2_242_0_51, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sleep",505,G__G__Base2_242_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - milliSec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Exec",389,G__G__Base2_242_0_53, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - shellcmd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenPipe",800,G__G__Base2_242_0_54, 69, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - command C - - 10 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClosePipe",900,G__G__Base2_242_0_55, 105, -1, -1, 0, 1, 1, 1, 0, "E - - 0 - pipe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFromPipe",1090,G__G__Base2_242_0_56, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 1, 1, 1, 0, "C - - 10 - command", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Exit",410,G__G__Base2_242_0_57, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - code g - 'Bool_t' 0 'kTRUE' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Abort",504,G__G__Base2_242_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 '0' code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPid",573,G__G__Base2_242_0_59, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StackTrace",997,G__G__Base2_242_0_60, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeDirectory",1331,G__G__Base2_242_0_61, 105, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenDirectory",1351,G__G__Base2_242_0_62, 89, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FreeDirectory",1335,G__G__Base2_242_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - dirp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirEntry",1105,G__G__Base2_242_0_64, 67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 - dirp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirPtr",885,G__G__Base2_242_0_65, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeDirectory",1531,G__G__Base2_242_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WorkingDirectory",1686,G__G__Base2_242_0_67, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HomeDirectory",1342,G__G__Base2_242_0_68, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 '0' userName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("mkdir",535,G__G__Base2_242_0_69, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' recursive", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("cd",199,G__G__Base2_242_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pwd",331,G__G__Base2_242_0_71, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TempDirectory",1355,G__G__Base2_242_0_72, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TempFileName",1175,G__G__Base2_242_0_73, 69, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 1 - base C - - 10 '0' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BaseName",764,G__G__Base2_242_0_74, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - pathname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirName",672,G__G__Base2_242_0_75, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - pathname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConcatFileName",1369,G__G__Base2_242_0_76, 67, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - dir C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAbsoluteFileName",1788,G__G__Base2_242_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFileInIncludePath",1860,G__G__Base2_242_0_78, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 2 '0' fullpath", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrependPathName",1500,G__G__Base2_242_0_79, 67, -1, -1, 0, 2, 1, 1, 1, 
"C - - 10 - dir u 'TString' - 1 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandPathName",1390,G__G__Base2_242_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 1 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandPathName",1390,G__G__Base2_242_0_81, 67, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AccessPathName",1376,G__G__Base2_242_0_82, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - path i 'EAccessMode' - 0 'kFileExists' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsPathLocal",1076,G__G__Base2_242_0_83, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyFile",795,G__G__Base2_242_0_84, 105, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - from C - - 10 - to "
"g - 'Bool_t' 0 'kFALSE' overwrite", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rename",600,G__G__Base2_242_0_85, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - from C - - 10 - to", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Link",398,G__G__Base2_242_0_86, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - from C - - 10 - to", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Symlink",743,G__G__Base2_242_0_87, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - from C - - 10 - to", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unlink",625,G__G__Base2_242_0_88, 105, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPathInfo",1081,G__G__Base2_242_0_89, 105, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - path L - 'Long_t' 0 - id "
"L - 'Long_t' 0 - size L - 'Long_t' 0 - flags "
"L - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPathInfo",1081,G__G__Base2_242_0_90, 105, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - path L - 'Long_t' 0 - id "
"N - 'Long64_t' 0 - size L - 'Long_t' 0 - flags "
"L - 'Long_t' 0 - modtime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPathInfo",1081,G__G__Base2_242_0_91, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - path u 'FileStat_t' - 1 - buf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFsInfo",869,G__G__Base2_242_0_92, 105, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - path L - 'Long_t' 0 - id "
"L - 'Long_t' 0 - bsize L - 'Long_t' 0 - blocks "
"L - 'Long_t' 0 - bfree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Chmod",491,G__G__Base2_242_0_93, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - file h - 'UInt_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Umask",513,G__G__Base2_242_0_94, 105, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mask", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Utime",516,G__G__Base2_242_0_95, 105, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - file l - 'Long_t' 0 - modtime "
"l - 'Long_t' 0 - actime", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnixPathName",1202,G__G__Base2_242_0_96, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - unixpathname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFile",769,G__G__Base2_242_0_97, 67, -1, -1, 0, 3, 1, 1, 1, 
"C - - 10 - search u 'TString' - 1 - file "
"i 'EAccessMode' - 0 'kFileExists' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Which",499,G__G__Base2_242_0_98, 67, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - search C - - 10 - file "
"i 'EAccessMode' - 0 'kFileExists' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVolumes",1035,G__G__Base2_242_0_99, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUid",578,G__G__Base2_242_0_100, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' user", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGid",564,G__G__Base2_242_0_101, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' group", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEffectiveUid",1491,G__G__Base2_242_0_102, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEffectiveGid",1477,G__G__Base2_242_0_103, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserInfo",1099,G__G__Base2_242_0_104, 85, G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserInfo",1099,G__G__Base2_242_0_105, 85, G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 0, 1, 1, 1, 0, "C - - 10 '0' user", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGroupInfo",1209,G__G__Base2_242_0_106, 85, G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - gid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGroupInfo",1209,G__G__Base2_242_0_107, 85, G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 0, 1, 1, 1, 0, "C - - 10 '0' group", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setenv",629,G__G__Base2_242_0_108, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unsetenv",856,G__G__Base2_242_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Getenv",617,G__G__Base2_242_0_110, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - env", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Openlog",724,G__G__Base2_242_0_111, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - options "
"i 'ELogFacility' - 0 - facility", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Syslog",641,G__G__Base2_242_0_112, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'ELogLevel' - 0 - level C - - 10 - mess", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Closelog",824,G__G__Base2_242_0_113, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RedirectOutput",1475,G__G__Base2_242_0_114, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"a\"' mode "
"U 'RedirectHandle_t' - 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowOutput",1074,G__G__Base2_242_0_115, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RedirectHandle_t' - 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddDynamicPath",1371,G__G__Base2_242_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - pathname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDynamicPath",1394,G__G__Base2_242_0_117, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDynamicPath",1406,G__G__Base2_242_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - pathname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DynamicPathName",1491,G__G__Base2_242_0_119, 67, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - lib g - 'Bool_t' 0 'kFALSE' quiet", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DynFindSymbol",1314,G__G__Base2_242_0_120, 89, -1, G__defined_typename("Func_t"), 0, 2, 1, 1, 0, 
"C - - 10 - module C - - 10 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Load",384,G__G__Base2_242_0_121, 105, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - module C - - 10 '\"\"' entry "
"g - 'Bool_t' 0 'kFALSE' system", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unload",611,G__G__Base2_242_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - module", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ListSymbols",1157,G__G__Base2_242_0_123, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - module C - - 10 '\"\"' re", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ListLibraries",1337,G__G__Base2_242_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' regexp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLibraries",1213,G__G__Base2_242_0_125, 67, -1, -1, 0, 3, 1, 1, 1, 
"C - - 10 '\"\"' regexp C - - 10 '\"\"' option "
"g - 'Bool_t' 0 'kTRUE' isRegexp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHostByName",1274,G__G__Base2_242_0_126, 117, G__get_linked_tagnum(&G__G__Base2LN_TInetAddress), -1, 0, 1, 1, 1, 0, "C - - 10 - server", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPeerName",1069,G__G__Base2_242_0_127, 117, G__get_linked_tagnum(&G__G__Base2LN_TInetAddress), -1, 0, 1, 1, 1, 0, "i - - 0 - sock", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSockName",1073,G__G__Base2_242_0_128, 117, G__get_linked_tagnum(&G__G__Base2LN_TInetAddress), -1, 0, 1, 1, 1, 0, "i - - 0 - sock", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetServiceByName",1581,G__G__Base2_242_0_129, 105, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - service", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetServiceByPort",1617,G__G__Base2_242_0_130, 67, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - port", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenConnection",1442,G__G__Base2_242_0_131, 105, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - server i - - 0 - port "
"i - - 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnnounceTcpService",1839,G__G__Base2_242_0_132, 105, -1, -1, 0, 4, 1, 1, 0, 
"i - - 0 - port g - 'Bool_t' 0 - reuse "
"i - - 0 - backlog i - - 0 '-1' tcpwindowsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnnounceUnixService",1964,G__G__Base2_242_0_133, 105, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - port i - - 0 - backlog", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnnounceUnixService",1964,G__G__Base2_242_0_134, 105, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - sockpath i - - 0 - backlog", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AcceptConnection",1632,G__G__Base2_242_0_135, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - sock", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseConnection",1542,G__G__Base2_242_0_136, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - sock g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecvRaw",698,G__G__Base2_242_0_137, 105, -1, -1, 0, 4, 1, 1, 0, 
"i - - 0 - sock Y - - 0 - buffer "
"i - - 0 - length i - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendRaw",692,G__G__Base2_242_0_138, 105, -1, -1, 0, 4, 1, 1, 0, 
"i - - 0 - sock Y - - 10 - buffer "
"i - - 0 - length i - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecvBuf",685,G__G__Base2_242_0_139, 105, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - sock Y - - 0 - buffer "
"i - - 0 - length", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendBuf",679,G__G__Base2_242_0_140, 105, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - sock Y - - 10 - buffer "
"i - - 0 - length", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSockOpt",1007,G__G__Base2_242_0_141, 105, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - sock i - - 0 - kind "
"i - - 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSockOpt",995,G__G__Base2_242_0_142, 105, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - sock i - - 0 - kind "
"I - - 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSysInfo",1003,G__G__Base2_242_0_143, 105, -1, -1, 0, 1, 1, 1, 8, "U 'SysInfo_t' - 0 - info", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCpuInfo",980,G__G__Base2_242_0_144, 105, -1, -1, 0, 2, 1, 1, 8, 
"U 'CpuInfo_t' - 0 - info i - 'Int_t' 0 '1000' sampleTime", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMemInfo",971,G__G__Base2_242_0_145, 105, -1, -1, 0, 1, 1, 1, 8, "U 'MemInfo_t' - 0 - info", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProcInfo",1088,G__G__Base2_242_0_146, 105, -1, -1, 0, 1, 1, 1, 8, "U 'ProcInfo_t' - 0 - info", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddIncludePath",1370,G__G__Base2_242_0_147, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - includePath", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLinkedLibs",1258,G__G__Base2_242_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - linkedLib", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CompileMacro",1211,G__G__Base2_242_0_149, 105, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' opt "
"C - - 10 '\"\"' library_name C - - 10 '\"\"' build_dir "
"h - 'UInt_t' 0 '0' dirmode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAclicProperties",1833,G__G__Base2_242_0_150, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuildArch",1166,G__G__Base2_242_0_151, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuildCompiler",1611,G__G__Base2_242_0_152, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuildCompilerVersion",2353,G__G__Base2_242_0_153, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuildNode",1174,G__G__Base2_242_0_154, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuildDir",1071,G__G__Base2_242_0_155, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFlagsDebug",1268,G__G__Base2_242_0_156, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFlagsOpt",1088,G__G__Base2_242_0_157, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIncludePath",1393,G__G__Base2_242_0_158, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLinkedLibs",1281,G__G__Base2_242_0_159, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLinkdefSuffix",1618,G__G__Base2_242_0_160, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAclicMode",1153,G__G__Base2_242_0_161, 105, G__get_linked_tagnum(&G__G__Base2LN_TSystemcLcLEAclicMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeExe",960,G__G__Base2_242_0_162, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeSharedLib",1548,G__G__Base2_242_0_163, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSoExt",787,G__G__Base2_242_0_164, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjExt",876,G__G__Base2_242_0_165, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBuildDir",1083,G__G__Base2_242_0_166, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - build_dir g - 'Bool_t' 0 'kFALSE' isflat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFlagsDebug",1280,G__G__Base2_242_0_167, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFlagsOpt",1100,G__G__Base2_242_0_168, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIncludePath",1405,G__G__Base2_242_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - includePath", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMakeExe",972,G__G__Base2_242_0_170, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - directives", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAclicMode",1165,G__G__Base2_242_0_171, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TSystem::EAclicMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMakeSharedLib",1560,G__G__Base2_242_0_172, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - directives", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLinkedLibs",1293,G__G__Base2_242_0_173, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - linkedLibs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLinkdefSuffix",1630,G__G__Base2_242_0_174, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - suffix", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSoExt",799,G__G__Base2_242_0_175, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - soExt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObjExt",888,G__G__Base2_242_0_176, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - objExt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SplitAclicMode",1389,G__G__Base2_242_0_177, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 0, 4, 1, 1, 8, 
"C - - 10 - filename u 'TString' - 1 - mode "
"u 'TString' - 1 - args u 'TString' - 1 - io", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CleanCompiledMacros",1909,G__G__Base2_242_0_178, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_242_0_179, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSystem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_242_0_180, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_242_0_181, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSystem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_242_0_182, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSystem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_242_0_186, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_242_0_187, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_242_0_188, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSystem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_242_0_189, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSystem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_242_0_190, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSystem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSystem", 855, G__G__Base2_242_0_191, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlETStringcOallocatorlETStringgRsPgR(void) {
   /* vector<TString,allocator<TString> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__memfunc_setup("at",213,G__G__Base2_253_0_1, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "h - 'vector<TString,allocator<TString> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Base2_253_0_2, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Base2_253_0_3, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Base2_253_0_4, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), G__defined_typename("vector<TString,allocator<TString> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Base2_253_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), G__defined_typename("vector<TString,allocator<TString> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Base2_253_0_6, 104, -1, G__defined_typename("vector<TString,allocator<TString> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Base2_253_0_7, 104, -1, G__defined_typename("vector<TString,allocator<TString> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Base2_253_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<TString,allocator<TString> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Base2_253_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<TString,allocator<TString> >::size_type' 0 - sz u 'TString' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__G__Base2_253_0_10, 104, -1, G__defined_typename("vector<TString,allocator<TString> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Base2_253_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_253_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 1, 1, 1, 0, "h - 'vector<TString,allocator<TString> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TString,allocator<TString> >",3370,G__G__Base2_253_0_13, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TString,allocator<TString> >",3370,G__G__Base2_253_0_14, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - 'vector<TString,allocator<TString> >::size_type' 0 - n u 'TString' - 11 'TString()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TString,allocator<TString> >",3370,G__G__Base2_253_0_15, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TString,allocator<TString> >",3370,G__G__Base2_253_0_16, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >::iterator' 'vector<TString,allocator<TString> >::const_iterator' 10 - first u 'vector<TString,allocator<TString> >::iterator' 'vector<TString,allocator<TString> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_253_0_17, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__G__Base2_253_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<TString,allocator<TString> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__G__Base2_253_0_19, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__G__Base2_253_0_20, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Base2_253_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Base2_253_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_253_0_23, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >::iterator' - 0 - position u 'TString' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_253_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >::iterator' - 0 - position u 'vector<TString,allocator<TString> >::iterator' 'vector<TString,allocator<TString> >::const_iterator' 10 - first "
"u 'vector<TString,allocator<TString> >::iterator' 'vector<TString,allocator<TString> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_253_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >::iterator' - 0 - position h - 'vector<TString,allocator<TString> >::size_type' 0 - n "
"u 'TString' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__G__Base2_253_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Base2_253_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Base2_253_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >::iterator' - 0 - first u 'vector<TString,allocator<TString> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Base2_253_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<TString,allocator<TString> >", 3496, G__G__Base2_253_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator(void) {
   /* vector<TString,allocator<TString> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Base2_254_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Base2_254_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 5, 1, 0, "U 'TString' 'vector<TString,allocator<TString> >::iterator::pointer' 11 - __i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Base2_254_0_3, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("vector<TString,allocator<TString> >::iterator::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Base2_254_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("vector<TString,allocator<TString> >::iterator::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_254_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_254_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_254_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_254_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_254_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("vector<TString,allocator<TString> >::iterator::reference"), 1, 1, 1, 1, 8, "l - 'vector<TString,allocator<TString> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_254_0_10, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<TString,allocator<TString> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Base2_254_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<TString,allocator<TString> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Base2_254_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<TString,allocator<TString> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Base2_254_0_13, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<TString,allocator<TString> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Base2_254_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("vector<TString,allocator<TString> >::iterator::pointer"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_254_0_15, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("iterator", 874, G__G__Base2_254_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Base2_254_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncreverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR(void) {
   /* reverse_iterator<vector<TString,allocator<TString> >::iterator> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR));
   G__memfunc_setup("reverse_iterator<vector<TString,allocator<TString> >::iterator>",6215,G__G__Base2_255_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Base2_255_0_2, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 8, "", "explicit", (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Base2_255_0_3, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("reverse_iterator<vector<TString,allocator<TString> >::iterator>::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Base2_255_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("reverse_iterator<vector<TString,allocator<TString> >::iterator>::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_255_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_255_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_255_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_255_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Base2_255_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 8, "l - 'reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_255_0_10, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "l - 'reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Base2_255_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 8, "l - 'reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Base2_255_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "l - 'reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_255_0_13, 117, G__get_linked_tagnum(&G__G__Base2LN_TString), G__defined_typename("reverse_iterator<vector<TString,allocator<TString> >::iterator>::reference"), 1, 1, 1, 1, 8, "l - 'reverse_iterator<vector<TString,allocator<TString> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("reverse_iterator<vector<TString,allocator<TString> >::iterator>", 6215, G__G__Base2_255_0_14, (int) ('i'), 
G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "u 'reverse_iterator<vector<TString,allocator<TString> >::iterator>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~reverse_iterator<vector<TString,allocator<TString> >::iterator>", 6341, G__G__Base2_255_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_255_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "u 'reverse_iterator<vector<TString,allocator<TString> >::iterator>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSysEvtHandler(void) {
   /* TSysEvtHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TSysEvtHandler));
   G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 4, 0, "", "used to set gTQSender", (void*) NULL, 1);
   G__memfunc_setup("Activate",817,G__G__Base2_256_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeActivate",986,G__G__Base2_256_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__Base2_256_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Base2_256_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Remove",622,G__G__Base2_256_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Activated",917,G__G__Base2_256_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DeActivated",1086,G__G__Base2_256_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Notified",818,G__G__Base2_256_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Added",466,G__G__Base2_256_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Removed",722,G__G__Base2_256_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Base2_256_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSysEvtHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_256_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSysEvtHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_256_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSysEvtHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_256_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSysEvtHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_256_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_256_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSysEvtHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_256_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSysEvtHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_256_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSysEvtHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_256_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSysEvtHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSysEvtHandler", 1534, G__G__Base2_256_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTStdExceptionHandler(void) {
   /* TStdExceptionHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandler));
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,G__G__Base2_261_0_5, 105, G__get_linked_tagnum(&G__G__Base2LN_TStdExceptionHandlercLcLEStatus), -1, 0, 1, 1, 1, 0, "u 'exception' - 1 - exc", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Base2_261_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStdExceptionHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_261_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStdExceptionHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_261_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStdExceptionHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_261_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStdExceptionHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_261_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_261_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStdExceptionHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_261_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStdExceptionHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_261_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStdExceptionHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_261_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStdExceptionHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TStdExceptionHandler", 2154, G__G__Base2_261_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTime(void) {
   /* TTime */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TTime));
   G__memfunc_setup("TTime",483,G__G__Base2_263_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTime",483,G__G__Base2_263_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - msec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTime",483,G__G__Base2_263_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 1, 1, 1, 0, "u 'TTime' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_263_0_4, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 1, 1, 1, 1, 0, "u 'TTime' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_263_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 1, 1, 1, 0, "u 'TTime' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Base2_263_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 1, 1, 1, 0, "u 'TTime' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Base2_263_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 1, 1, 1, 0, "u 'TTime' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Base2_263_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 1, 1, 1, 0, "u 'TTime' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator long",1340,G__G__Base2_263_0_9, 108, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator unsigned long",2233,G__G__Base2_263_0_10, 107, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator long long",1804,G__G__Base2_263_0_11, 110, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator unsigned long long",2697,G__G__Base2_263_0_12, 109, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Base2_263_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_263_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTime::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_263_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTime::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_263_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTime::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_263_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTime::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_263_0_18, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_263_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_263_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_263_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_263_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTime::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_263_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTime::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_263_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTime::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_263_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTime::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTime", 609, G__G__Base2_263_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncFileStat_t(void) {
   /* FileStat_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_FileStat_t));
   G__memfunc_setup("FileStat_t",1007,G__G__Base2_272_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_FileStat_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FileStat_t", 1007, G__G__Base2_272_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_FileStat_t), -1, 0, 1, 1, 1, 0, "u 'FileStat_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FileStat_t", 1133, G__G__Base2_272_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_272_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_FileStat_t), -1, 1, 1, 1, 1, 0, "u 'FileStat_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncUserGroup_t(void) {
   /* UserGroup_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t));
   G__memfunc_setup("UserGroup_t",1151,G__G__Base2_273_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("UserGroup_t", 1151, G__G__Base2_273_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 0, 1, 1, 1, 0, "u 'UserGroup_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~UserGroup_t", 1277, G__G__Base2_273_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_273_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_UserGroup_t), -1, 1, 1, 1, 1, 0, "u 'UserGroup_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncSysInfo_t(void) {
   /* SysInfo_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t));
   G__memfunc_setup("SysInfo_t",926,G__G__Base2_274_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_274_0_2, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&SysInfo_t::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_274_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SysInfo_t::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_274_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&SysInfo_t::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_274_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&SysInfo_t::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_274_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_274_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_274_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_274_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_274_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SysInfo_t::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_274_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&SysInfo_t::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_274_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SysInfo_t::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_274_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&SysInfo_t::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SysInfo_t", 926, G__G__Base2_274_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t), -1, 0, 1, 1, 1, 0, "u 'SysInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SysInfo_t", 1052, G__G__Base2_274_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_274_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_SysInfo_t), -1, 1, 1, 1, 1, 0, "u 'SysInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCpuInfo_t(void) {
   /* CpuInfo_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t));
   G__memfunc_setup("CpuInfo_t",903,G__G__Base2_275_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_275_0_2, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&CpuInfo_t::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_275_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&CpuInfo_t::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_275_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&CpuInfo_t::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_275_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&CpuInfo_t::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_275_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_275_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_275_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_275_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_275_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&CpuInfo_t::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_275_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&CpuInfo_t::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_275_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&CpuInfo_t::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_275_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&CpuInfo_t::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("CpuInfo_t", 903, G__G__Base2_275_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t), -1, 0, 1, 1, 1, 0, "u 'CpuInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~CpuInfo_t", 1029, G__G__Base2_275_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_275_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_CpuInfo_t), -1, 1, 1, 1, 1, 0, "u 'CpuInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncMemInfo_t(void) {
   /* MemInfo_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t));
   G__memfunc_setup("MemInfo_t",894,G__G__Base2_276_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_276_0_2, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&MemInfo_t::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_276_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&MemInfo_t::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_276_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&MemInfo_t::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_276_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&MemInfo_t::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_276_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_276_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_276_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_276_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_276_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&MemInfo_t::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_276_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&MemInfo_t::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_276_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&MemInfo_t::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_276_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&MemInfo_t::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MemInfo_t", 894, G__G__Base2_276_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t), -1, 0, 1, 1, 1, 0, "u 'MemInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MemInfo_t", 1020, G__G__Base2_276_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_276_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_MemInfo_t), -1, 1, 1, 1, 1, 0, "u 'MemInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncProcInfo_t(void) {
   /* ProcInfo_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t));
   G__memfunc_setup("ProcInfo_t",1011,G__G__Base2_277_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_277_0_2, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ProcInfo_t::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_277_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ProcInfo_t::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_277_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ProcInfo_t::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_277_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ProcInfo_t::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Base2_277_0_6, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Base2_277_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Base2_277_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_277_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_277_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ProcInfo_t::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_277_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ProcInfo_t::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_277_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ProcInfo_t::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_277_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ProcInfo_t::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ProcInfo_t", 1011, G__G__Base2_277_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t), -1, 0, 1, 1, 1, 0, "u 'ProcInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ProcInfo_t", 1137, G__G__Base2_277_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_277_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_ProcInfo_t), -1, 1, 1, 1, 1, 0, "u 'ProcInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRedirectHandle_t(void) {
   /* RedirectHandle_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t));
   G__memfunc_setup("RedirectHandle_t",1617,G__G__Base2_278_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t), -1, 0, 1, 1, 1, 0, "C - - 10 '0' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Base2_278_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("RedirectHandle_t", 1617, G__G__Base2_278_0_3, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t), -1, 0, 1, 1, 1, 0, "u 'RedirectHandle_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~RedirectHandle_t", 1743, G__G__Base2_278_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_278_0_5, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_RedirectHandle_t), -1, 1, 1, 1, 1, 0, "u 'RedirectHandle_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProcessEventTimer(void) {
   /* TProcessEventTimer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer));
   G__memfunc_setup("TProcessEventTimer",1846,G__G__Base2_279_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TProcessEventTimer), -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - delay", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvents",1364,G__G__Base2_279_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_279_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProcessEventTimer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_279_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessEventTimer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_279_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProcessEventTimer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_279_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProcessEventTimer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_279_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_279_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessEventTimer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_279_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProcessEventTimer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_279_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProcessEventTimer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_279_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProcessEventTimer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProcessEventTimer", 1972, G__G__Base2_279_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRemoteObject(void) {
   /* TRemoteObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject));
   G__memfunc_setup("TRemoteObject",1303,G__G__Base2_282_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRemoteObject",1303,G__G__Base2_282_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,G__G__Base2_282_0_5, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFileStat",1084,G__G__Base2_282_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'FileStat_t' - 0 - sbuf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassName",1175,G__G__Base2_282_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeyObjectName",1569,G__G__Base2_282_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeyClassName",1472,G__G__Base2_282_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFolder",904,G__G__Base2_282_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isFolder", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKeyObjectName",1581,G__G__Base2_282_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKeyClassName",1484,G__G__Base2_282_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRemoteAddress",1630,G__G__Base2_282_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - addr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_282_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRemoteObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_282_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRemoteObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_282_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRemoteObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_282_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRemoteObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_282_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_282_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRemoteObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_282_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRemoteObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_282_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRemoteObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_282_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRemoteObject::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRemoteObject", 1303, G__G__Base2_282_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject), -1, 0, 1, 1, 1, 0, "u 'TRemoteObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRemoteObject", 1429, G__G__Base2_282_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_282_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_TRemoteObject), -1, 1, 1, 1, 1, 0, "u 'TRemoteObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTROOT(void) {
   /* TROOT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TROOT));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Base2LN_TROOT), -1, 1, 1, 1, 4, 0, "u 'TROOT' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitSystem",1049,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Operating System interface", (void*) NULL, 0);
   G__memfunc_setup("InitThreads",1119,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Initialize threads library", (void*) NULL, 0);
   G__memfunc_setup("ReadSvnInfo",1087,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Read Subversion revision number and branch name", (void*) NULL, 0);
   G__memfunc_setup("operator new",1238,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 1, 1, 2, 0, "h - 'size_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClass",767,G__G__Base2_288_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClassGenerator",1702,G__G__Base2_288_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClassGenerator' - 0 - gen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClassSaved",1001,G__G__Base2_288_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObjectAny",1280,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindSpecialObject",1689,G__G__Base2_288_0_16, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name Y - - 1 - where", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindObjectClassName",1871,G__G__Base2_288_0_17, 67, -1, -1, 0, 1, 1, 1, 9, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindObjectPathName",1766,G__G__Base2_288_0_18, 67, -1, -1, 0, 1, 1, 1, 9, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindSTLClass",1130,G__G__Base2_288_0_19, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 3, 1, 1, 8, 
"C - - 10 - name g - 'Bool_t' 0 - load "
"g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceStyle",1024,G__G__Base2_288_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FromPopUp",904,G__G__Base2_288_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPluginManager",1610,G__G__Base2_288_0_22, 85, G__get_linked_tagnum(&G__G__Base2LN_TPluginManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetApplication",1428,G__G__Base2_288_0_23, 85, G__get_linked_tagnum(&G__G__Base2LN_TApplication), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterpreter",1460,G__G__Base2_288_0_24, 85, G__get_linked_tagnum(&G__G__Base2LN_TInterpreter), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Base2_288_0_25, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 3, 1, 1, 8, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' load "
"g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__Base2_288_0_26, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 3, 1, 1, 8, 
"u 'type_info' - 11 - typeinfo g - 'Bool_t' 0 'kTRUE' load "
"g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColor",799,G__G__Base2_288_0_27, 85, G__get_linked_tagnum(&G__G__Base2LN_TColor), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfigOptions",1634,G__G__Base2_288_0_28, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfigFeatures",1717,G__G__Base2_288_0_29, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCutClassName",1475,G__G__Base2_288_0_30, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefCanvasName",1548,G__G__Base2_288_0_31, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditHistograms",1735,G__G__Base2_288_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditorMode",1292,G__G__Base2_288_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetForceStyle",1312,G__G__Base2_288_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuiltDate",1182,G__G__Base2_288_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuiltTime",1199,G__G__Base2_288_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSvnRevision",1446,G__G__Base2_288_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSvnBranch",1189,G__G__Base2_288_0_38, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSvnDate",981,G__G__Base2_288_0_39, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersionDate",1412,G__G__Base2_288_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersionTime",1429,G__G__Base2_288_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersionInt",1329,G__G__Base2_288_0_42, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersionCode",1409,G__G__Base2_288_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersion",1030,G__G__Base2_288_0_44, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfClasses",1599,G__G__Base2_288_0_45, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfColors",1507,G__G__Base2_288_0_46, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfTypes",1414,G__G__Base2_288_0_47, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfGlobals",1589,G__G__Base2_288_0_48, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfGlobalFunctions",2427,G__G__Base2_288_0_49, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFiles",1380,G__G__Base2_288_0_50, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMappedFiles",1979,G__G__Base2_288_0_51, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfSockets",1613,G__G__Base2_288_0_52, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfCanvases",1701,G__G__Base2_288_0_53, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfStyles",1525,G__G__Base2_288_0_54, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Base2_288_0_55, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfGeometries",1925,G__G__Base2_288_0_56, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfBrowsers",1736,G__G__Base2_288_0_57, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfSpecials",1701,G__G__Base2_288_0_58, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfTasks",1399,G__G__Base2_288_0_59, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfCleanups",1708,G__G__Base2_288_0_60, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfStreamerInfo",2112,G__G__Base2_288_0_61, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMessageHandlers",2407,G__G__Base2_288_0_62, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfClassGenerators",2433,G__G__Base2_288_0_63, 85, G__get_linked_tagnum(&G__G__Base2LN_TCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfSecContexts",2020,G__G__Base2_288_0_64, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfProofs",1514,G__G__Base2_288_0_65, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipboard",1200,G__G__Base2_288_0_66, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfDataSets",1674,G__G__Base2_288_0_67, 85, G__get_linked_tagnum(&G__G__Base2LN_TSeqCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfBrowsables",1925,G__G__Base2_288_0_68, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Base2_288_0_69, 85, G__get_linked_tagnum(&G__G__Base2LN_TDataType), -1, 0, 2, 1, 1, 8, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFile",672,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFile",672,G__G__Base2_288_0_71, 85, G__get_linked_tagnum(&G__G__Base2LN_TFile), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStyle",817,G__G__Base2_288_0_72, 85, G__get_linked_tagnum(&G__G__Base2LN_TStyle), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunction",1126,G__G__Base2_288_0_73, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobal",881,G__G__Base2_288_0_74, 85, G__get_linked_tagnum(&G__G__Base2LN_TGlobal), -1, 0, 2, 1, 1, 8, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobal",881,G__G__Base2_288_0_75, 85, G__get_linked_tagnum(&G__G__Base2LN_TGlobal), -1, 0, 2, 1, 1, 8, 
"U 'TObject' - 10 - obj g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalFunction",1719,G__G__Base2_288_0_76, 85, G__get_linked_tagnum(&G__G__Base2LN_TFunction), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '0' params "
"g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalFunctionWithPrototype",3113,G__G__Base2_288_0_77, 85, G__get_linked_tagnum(&G__G__Base2LN_TFunction), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '0' proto "
"g - 'Bool_t' 0 'kFALSE' load", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeometry",1132,G__G__Base2_288_0_78, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedPrimitive",2050,G__G__Base2_288_0_79, 85, G__get_linked_tagnum(&G__G__Base2LN_TObject), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedPad",1374,G__G__Base2_288_0_80, 85, G__get_linked_tagnum(&G__G__Base2LN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNclasses",1116,G__G__Base2_288_0_81, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNtypes",931,G__G__Base2_288_0_82, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRootFolder",1312,G__G__Base2_288_0_83, 85, G__get_linked_tagnum(&G__G__Base2LN_TFolder), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUUIDs",714,G__G__Base2_288_0_84, 85, G__get_linked_tagnum(&G__G__Base2LN_TProcessUUID), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Idle",382,G__G__Base2_288_0_85, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - idleTimeInSec C - - 10 '0' command", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IgnoreInclude",1320,G__G__Base2_288_0_86, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - fname C - - 10 - expandedfname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBatch",670,G__G__Base2_288_0_87, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsExecutingMacro",1626,G__G__Base2_288_0_88, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInterrupted",1362,G__G__Base2_288_0_90, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEscaped",881,G__G__Base2_288_0_91, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLineProcessing",1633,G__G__Base2_288_0_92, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsProofServ",1122,G__G__Base2_288_0_93, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadClass",886,G__G__Base2_288_0_95, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - classname C - - 10 - libname "
"g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadClass",886,G__G__Base2_288_0_96, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 2, 1, 1, 8, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' silent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMacro",882,G__G__Base2_288_0_97, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - filename I - 'Int_t' 0 '0' error "
"g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Macro",498,G__G__Base2_288_0_98, 108, -1, G__defined_typename("Long_t"), 0, 3, 1, 1, 0, 
"C - - 10 - filename I - 'Int_t' 0 '0' error "
"g - 'Bool_t' 0 'kTRUE' padUpdate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeDefCanvas",1257,G__G__Base2_288_0_99, 85, G__get_linked_tagnum(&G__G__Base2LN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Message",709,G__G__Base2_288_0_100, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - id U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MustClean",908,G__G__Base2_288_0_101, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessLine",1127,G__G__Base2_288_0_102, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - line I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessLineSync",1540,G__G__Base2_288_0_103, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - line I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessLineFast",1525,G__G__Base2_288_0_104, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 - line I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadingObject",1297,G__G__Base2_288_0_105, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefreshBrowsers",1574,G__G__Base2_288_0_106, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveClass",1124,G__G__Base2_288_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Base2_288_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveContext",1140,G__G__Base2_288_0_109, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetApplication",1440,G__G__Base2_288_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TApplication' - 0 - app", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBatch",782,G__G__Base2_288_0_111, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' batch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCutClassName",1487,G__G__Base2_288_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"TCutG\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefCanvasName",1560,G__G__Base2_288_0_113, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"c1\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditHistograms",1747,G__G__Base2_288_0_114, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditorMode",1304,G__G__Base2_288_0_115, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExecutingMacro",1738,G__G__Base2_288_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFromPopUp",1204,G__G__Base2_288_0_117, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInterrupt",1273,G__G__Base2_288_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEscape",893,G__G__Base2_288_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineIsProcessing",1933,G__G__Base2_288_0_120, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineHasBeenProcessed",2290,G__G__Base2_288_0_121, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadingObject",1597,G__G__Base2_288_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMustClean",1208,G__G__Base2_288_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelectedPrimitive",2062,G__G__Base2_288_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelectedPad",1386,G__G__Base2_288_0_125, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStyle",829,G__G__Base2_288_0_126, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"Default\"' stylename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Time",399,G__G__Base2_288_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' casetime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Timer",513,G__G__Base2_288_0_128, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecreaseDirLevel",1587,G__G__Base2_288_0_129, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TROOT::DecreaseDirLevel) ), 0);
   G__memfunc_setup("GetDirLevel",1079,G__G__Base2_288_0_130, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TROOT::GetDirLevel) ), 0);
   G__memfunc_setup("GetMacroPath",1183,G__G__Base2_288_0_131, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TROOT::GetMacroPath) ), 0);
   G__memfunc_setup("SetMacroPath",1195,G__G__Base2_288_0_132, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - newpath", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TROOT::SetMacroPath) ), 0);
   G__memfunc_setup("IncreaseDirLevel",1601,G__G__Base2_288_0_133, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TROOT::IncreaseDirLevel) ), 0);
   G__memfunc_setup("IndentLevel",1114,G__G__Base2_288_0_134, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TROOT::IndentLevel) ), 0);
   G__memfunc_setup("Initialized",1142,G__G__Base2_288_0_135, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TROOT::Initialized) ), 0);
   G__memfunc_setup("MemCheck",765,G__G__Base2_288_0_136, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TROOT::MemCheck) ), 0);
   G__memfunc_setup("SetDirLevel",1091,G__G__Base2_288_0_137, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '0' level", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TROOT::SetDirLevel) ), 0);
   G__memfunc_setup("ConvertVersionCode2Int",2207,G__G__Base2_288_0_138, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - code", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TROOT::ConvertVersionCode2Int) ), 0);
   G__memfunc_setup("ConvertVersionInt2Code",2207,G__G__Base2_288_0_139, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TROOT::ConvertVersionInt2Code) ), 0);
   G__memfunc_setup("RootVersionCode",1541,G__G__Base2_288_0_140, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TROOT::RootVersionCode) ), 0);
   G__memfunc_setup("Class",502,G__G__Base2_288_0_141, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TROOT::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_288_0_142, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TROOT::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_288_0_143, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TROOT::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_288_0_144, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TROOT::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_288_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_288_0_149, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TROOT::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_288_0_150, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TROOT::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_288_0_151, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TROOT::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_288_0_152, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TROOT::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TROOT", 534, G__G__Base2_288_0_153, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTask(void) {
   /* TTask */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_TTask));
   G__memfunc_setup("TTask",487,G__G__Base2_291_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_TTask), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTask",487,G__G__Base2_291_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_TTask), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTask",487,G__G__Base2_291_0_3, 105, G__get_linked_tagnum(&G__G__Base2LN_TTask), -1, 0, 1, 1, 1, 0, "u 'TTask' - 11 - task", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_291_0_4, 117, G__get_linked_tagnum(&G__G__Base2LN_TTask), -1, 1, 1, 1, 1, 0, "u 'TTask' - 11 - tt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Abort",504,G__G__Base2_291_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Base2_291_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTask' - 0 - task", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CleanTasks",1001,G__G__Base2_291_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Continue",837,G__G__Base2_291_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Exec",389,G__G__Base2_291_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteTask",1126,G__G__Base2_291_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"0\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteTasks",1241,G__G__Base2_291_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBreakin",988,G__G__Base2_291_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBreakout",1117,G__G__Base2_291_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__Base2_291_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"*\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetActive",904,G__G__Base2_291_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' active", "*TOGGLE*", (void*) NULL, 0);
   G__memfunc_setup("SetBreakin",1000,G__G__Base2_291_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' breakin", "*TOGGLE*", (void*) NULL, 0);
   G__memfunc_setup("SetBreakout",1129,G__G__Base2_291_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' breakout", "*TOGGLE*", (void*) NULL, 0);
   G__memfunc_setup("GetListOfTasks",1399,G__G__Base2_291_0_22, 85, G__get_linked_tagnum(&G__G__Base2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Base2_291_0_23, 85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTask::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Base2_291_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTask::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Base2_291_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTask::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Base2_291_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTask::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Base2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Base2_291_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Base2_291_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTask::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Base2_291_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTask::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Base2_291_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTask::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Base2_291_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTask::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTask", 613, G__G__Base2_291_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEstringcOallocatorlEstringgRsPgR(void) {
   /* vector<string,allocator<string> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__memfunc_setup("at",213,G__G__Base2_344_0_1, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "h - 'vector<string,allocator<string> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Base2_344_0_2, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Base2_344_0_3, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Base2_344_0_4, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), G__defined_typename("vector<string,allocator<string> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Base2_344_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), G__defined_typename("vector<string,allocator<string> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Base2_344_0_6, 104, -1, G__defined_typename("vector<string,allocator<string> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Base2_344_0_7, 104, -1, G__defined_typename("vector<string,allocator<string> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Base2_344_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<string,allocator<string> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Base2_344_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<string,allocator<string> >::size_type' 0 - sz u 'string' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__G__Base2_344_0_10, 104, -1, G__defined_typename("vector<string,allocator<string> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Base2_344_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_344_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 1, 1, 1, 0, "h - 'vector<string,allocator<string> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<string,allocator<string> >",3266,G__G__Base2_344_0_13, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<string,allocator<string> >",3266,G__G__Base2_344_0_14, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - 'vector<string,allocator<string> >::size_type' 0 - n u 'string' - 11 'string()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<string,allocator<string> >",3266,G__G__Base2_344_0_15, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<string,allocator<string> >",3266,G__G__Base2_344_0_16, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >::iterator' 'vector<string,allocator<string> >::const_iterator' 10 - first u 'vector<string,allocator<string> >::iterator' 'vector<string,allocator<string> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_344_0_17, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<string,allocator<string> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__G__Base2_344_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<string,allocator<string> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__G__Base2_344_0_19, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__G__Base2_344_0_20, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Base2_344_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Base2_344_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_344_0_23, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >::iterator' - 0 - position u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_344_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<string,allocator<string> >::iterator' - 0 - position u 'vector<string,allocator<string> >::iterator' 'vector<string,allocator<string> >::const_iterator' 10 - first "
"u 'vector<string,allocator<string> >::iterator' 'vector<string,allocator<string> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Base2_344_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<string,allocator<string> >::iterator' - 0 - position h - 'vector<string,allocator<string> >::size_type' 0 - n "
"u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__G__Base2_344_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Base2_344_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Base2_344_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >::iterator' - 0 - first u 'vector<string,allocator<string> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Base2_344_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<string,allocator<string> >", 3392, G__G__Base2_344_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator(void) {
   /* vector<string,allocator<string> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Base2_345_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Base2_345_0_2, 105, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 5, 1, 0, "U 'string' 'vector<string,allocator<string> >::iterator::pointer' 11 - __i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Base2_345_0_3, 117, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("vector<string,allocator<string> >::iterator::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Base2_345_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("vector<string,allocator<string> >::iterator::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_345_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_345_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_345_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_345_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_345_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("vector<string,allocator<string> >::iterator::reference"), 1, 1, 1, 1, 8, "l - 'vector<string,allocator<string> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_345_0_10, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<string,allocator<string> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Base2_345_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<string,allocator<string> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Base2_345_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<string,allocator<string> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Base2_345_0_13, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<string,allocator<string> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Base2_345_0_14, 85, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("vector<string,allocator<string> >::iterator::pointer"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Base2_345_0_15, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("iterator", 874, G__G__Base2_345_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Base2_345_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncreverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR(void) {
   /* reverse_iterator<vector<string,allocator<string> >::iterator> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR));
   G__memfunc_setup("reverse_iterator<vector<string,allocator<string> >::iterator>",6111,G__G__Base2_346_0_1, 105, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Base2_346_0_2, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 8, "", "explicit", (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Base2_346_0_3, 117, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("reverse_iterator<vector<string,allocator<string> >::iterator>::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Base2_346_0_4, 85, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("reverse_iterator<vector<string,allocator<string> >::iterator>::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_346_0_5, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Base2_346_0_6, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_346_0_7, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Base2_346_0_8, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Base2_346_0_9, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 8, "l - 'reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Base2_346_0_10, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "l - 'reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Base2_346_0_11, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 8, "l - 'reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Base2_346_0_12, 117, G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "l - 'reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Base2_346_0_13, 117, G__get_linked_tagnum(&G__G__Base2LN_string), G__defined_typename("reverse_iterator<vector<string,allocator<string> >::iterator>::reference"), 1, 1, 1, 1, 8, "l - 'reverse_iterator<vector<string,allocator<string> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("reverse_iterator<vector<string,allocator<string> >::iterator>", 6111, G__G__Base2_346_0_14, (int) ('i'), 
G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "u 'reverse_iterator<vector<string,allocator<string> >::iterator>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~reverse_iterator<vector<string,allocator<string> >::iterator>", 6237, G__G__Base2_346_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Base2_346_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "u 'reverse_iterator<vector<string,allocator<string> >::iterator>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Base2() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
   G__memvar_setup((void*)(&gTQSender),89,0,0,-1,-1,-1,1,"gTQSender=",0,(char*)NULL);
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
   G__memvar_setup((void*)(&gTQSlotParams),67,0,0,-1,-1,-1,1,"gTQSlotParams=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigBus=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigSegmentationViolation=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigSystem=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigPipe=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigIllegalInstruction=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigQuit=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigInterrupt=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigWindowChanged=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigAlarm=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigChild=9",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigUrgent=10",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigFloatingException=11",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigTermination=12",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigUser1=13",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESignals),-1,-1,1,"kSigUser2=14",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EAccessMode),-1,-1,1,"kFileExists=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EAccessMode),-1,-1,1,"kExecutePermission=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EAccessMode),-1,-1,1,"kWritePermission=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EAccessMode),-1,-1,1,"kReadPermission=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESysConstants),-1,-1,1,"kMAXSIGNALS=15",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESysConstants),-1,-1,1,"kMAXPATHLEN=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESysConstants),-1,-1,1,"kBUFFERSIZE=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_ESysConstants),-1,-1,1,"kItimerResolution=10",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kNoneMask=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kInvalid=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kDivByZero=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kOverflow=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kUnderflow=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kInexact=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kDefaultMask=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFpeMask),-1,-1,1,"kAllMask=31",0,(char*)NULL);
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFMT=61440",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFSOCK=49152",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFLNK=40960",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFOFF=36864",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFREG=32768",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFBLK=24576",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFDIR=16384",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFCHR=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IFIFO=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_ISUID=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_ISGID=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_ISVTX=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IRWXU=448",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IRUSR=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IWUSR=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IXUSR=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IRWXG=56",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IRGRP=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IWGRP=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IXGRP=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IRWXO=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IROTH=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IWOTH=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Base2LN_EFileModeMask),-1,-1,1,"kS_IXOTH=1",0,(char*)NULL);
}

static void G__cpp_setup_global5() {
}

static void G__cpp_setup_global6() {
}

static void G__cpp_setup_global7() {
}

static void G__cpp_setup_global8() {
}

static void G__cpp_setup_global9() {
   G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"G__STRING_DLL=0",1,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Base2() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
  G__cpp_setup_global7();
  G__cpp_setup_global8();
  G__cpp_setup_global9();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

   G__memfunc_setup("operator==", 998, G__G__Base2__0_85, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_86, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_87, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_88, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_89, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_90, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_91, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_92, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"c - - 0 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_93, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a c - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_94, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_95, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_96, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_97, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_98, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_99, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_100, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a C - - 10 - b", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func1() {
   G__memfunc_setup("operator==", 998, G__G__Base2__0_101, 103, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_102, 103, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_103, 103, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_104, 103, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_105, 103, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_106, 103, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_107, 117, G__get_linked_tagnum(&G__G__Base2LN_string), -1, 0, 2, 1, 1, 0, 
"C - - 10 - a u 'string' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("swap", 443, G__G__Base2__0_108, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 1 - lhs u 'string' - 1 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>>", 1000, G__G__Base2__0_109, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - is u 'string' - 1 - st", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<<", 996, G__G__Base2__0_110, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - is u 'string' - 11 - st", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("getline", 744, G__G__Base2__0_111, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - is u 'string' - 1 - st", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("getline", 744, G__G__Base2__0_112, 117, G__get_linked_tagnum(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 3, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - is u 'string' - 1 - st "
"c - - 0 - delim", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_113, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string::iterator' - 11 - _Left u 'string::iterator' - 11 - _Right", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_114, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string::iterator' - 11 - _Left u 'string::iterator' - 11 - _Right", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
   G__memfunc_setup("ConnectCINT", 1016, G__G__Base2__0_339, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"U 'TQObject' - 0 - sender C - - 10 - signal "
"C - - 10 - slot", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>>", 1000, G__G__Base2__0_350, 117, G__get_linked_tagnum(&G__G__Base2LN_TBuffer), -1, 1, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buf u 'TUUID' - 1 - uuid", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<<", 996, G__G__Base2__0_351, 117, G__get_linked_tagnum(&G__G__Base2LN_TBuffer), -1, 1, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buf u 'TUUID' - 11 - uuid", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_352, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TUUID' - 11 - u1 u 'TUUID' - 11 - u2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_353, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TUUID' - 11 - u1 u 'TUUID' - 11 - u2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_367, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMD5' - 11 - m1 u 'TMD5' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>>", 1000, G__G__Base2__0_368, 117, G__get_linked_tagnum(&G__G__Base2LN_TBuffer), -1, 1, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buf u 'TMD5' - 1 - md5", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<<", 996, G__G__Base2__0_369, 117, G__get_linked_tagnum(&G__G__Base2LN_TBuffer), -1, 1, 2, 1, 1, 0, 
"u 'TBuffer' - 1 - buf u 'TMD5' - 11 - md5", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_370, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMD5' - 11 - m1 u 'TMD5' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_382, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TRef' - 11 - r1 u 'TRef' - 11 - r2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_383, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TRef' - 11 - r1 u 'TRef' - 11 - r2", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func4() {
   G__memfunc_setup("operator==", 998, G__G__Base2__0_454, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_455, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_456, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_457, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_458, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_459, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Base2__0_460, 108, -1, G__defined_typename("difference_type"), 0, 2, 1, 1, 8, 
"u 'vector<TString,allocator<TString> >::iterator' - 11 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_461, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 8, 
"l - 'difference_type' 10 - x u 'vector<TString,allocator<TString> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_462, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'reverse_iterator<vector<TString,allocator<TString> >::iterator>' 'reverse_iterator' 11 - x u 'reverse_iterator<vector<TString,allocator<TString> >::iterator>' 'reverse_iterator' 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_463, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'reverse_iterator<vector<TString,allocator<TString> >::iterator>' 'reverse_iterator' 11 - x u 'reverse_iterator<vector<TString,allocator<TString> >::iterator>' 'reverse_iterator' 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_464, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' - 11 - x u 'vector<TString,allocator<TString> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_465, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' - 11 - x u 'vector<TString,allocator<TString> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_466, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' - 11 - x u 'vector<TString,allocator<TString> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_467, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' - 11 - x u 'vector<TString,allocator<TString> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_468, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' - 11 - x u 'vector<TString,allocator<TString> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_469, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' - 11 - x u 'vector<TString,allocator<TString> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func5() {
   G__memfunc_setup("operator+", 919, G__G__Base2__0_522, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Base2__0_523, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Base2__0_524, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Base2__0_525, 117, G__get_linked_tagnum(&G__G__Base2LN_TTime), -1, 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_526, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_527, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_528, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_529, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_530, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_531, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TTime' - 11 - t1 u 'TTime' - 11 - t2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISDIR", 556, G__G__Base2__0_532, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISCHR", 554, G__G__Base2__0_533, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISBLK", 550, G__G__Base2__0_534, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISREG", 555, G__G__Base2__0_535, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISLNK", 562, G__G__Base2__0_536, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISFIFO", 625, G__G__Base2__0_537, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISSOCK", 637, G__G__Base2__0_538, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R_ISOFF", 552, G__G__Base2__0_539, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_540, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_541, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_542, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_543, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_544, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_545, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Base2__0_546, 108, -1, G__defined_typename("difference_type"), 0, 2, 1, 1, 8, 
"u 'vector<string,allocator<string> >::iterator' - 11 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Base2__0_547, 117, G__get_linked_tagnum(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 8, 
"l - 'difference_type' 10 - x u 'vector<string,allocator<string> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_548, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'reverse_iterator<vector<string,allocator<string> >::iterator>' 'reverse_iterator' 11 - x u 'reverse_iterator<vector<string,allocator<string> >::iterator>' 'reverse_iterator' 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_549, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'reverse_iterator<vector<string,allocator<string> >::iterator>' 'reverse_iterator' 11 - x u 'reverse_iterator<vector<string,allocator<string> >::iterator>' 'reverse_iterator' 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Base2__0_550, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' - 11 - x u 'vector<string,allocator<string> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Base2__0_551, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' - 11 - x u 'vector<string,allocator<string> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Base2__0_552, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' - 11 - x u 'vector<string,allocator<string> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Base2__0_553, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' - 11 - x u 'vector<string,allocator<string> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Base2__0_554, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' - 11 - x u 'vector<string,allocator<string> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Base2__0_555, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' - 11 - x u 'vector<string,allocator<string> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Base2() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Base2LN_type_info = { "type_info" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TVirtualIsAProxy = { "TVirtualIsAProxy" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_stringcLcLiterator = { "string::iterator" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR = { "reverse_iterator<string::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStorage = { "TStorage" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_va_list = { "va_list" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMethod = { "TMethod" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TObjectcLcLEStatusBits = { "TObject::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TObjectcLcLdA = { "TObject::$" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TProcessID = { "TProcessID" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMemberInspectorcLcLTParentBuf = { "TMemberInspector::TParentBuf" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TRefCnt = { "TRefCnt" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TRefCntcLcLEReferenceFlag = { "TRefCnt::EReferenceFlag" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TRegexp = { "TRegexp" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TPRegexp = { "TPRegexp" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSubString = { "TSubString" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStringRef = { "TStringRef" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStringLong = { "TStringLong" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStringcLcLEStripType = { "TString::EStripType" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TStringcLcLECaseCompare = { "TString::ECaseCompare" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TQConnection = { "TQConnection" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TQObjSender = { "TQObjSender" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSignalHandler = { "TSignalHandler" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TApplication = { "TApplication" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStopwatchcLcLEState = { "TStopwatch::EState" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TColor = { "TColor" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TFunction = { "TFunction" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TDatime = { "TDatime" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TObjLink = { "TObjLink" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TInetAddress = { "TInetAddress" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TUUID = { "TUUID" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TUUIDcLcLuuid_time_t = { "TUUID::uuid_time_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_TEnv = { "TEnv" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TExec = { "TExec" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TFolder = { "TFolder" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TObjString = { "TObjString" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMD5 = { "TMD5" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMacro = { "TMacro" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMessageHandler = { "TMessageHandler" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_THashTable = { "THashTable" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TMethodCall = { "TMethodCall" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TPluginManager = { "TPluginManager" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TPluginHandler = { "TPluginHandler" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TPoint = { "TPoint" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_PCREPriv_t = { "PCREPriv_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_TPRegexpcLcLdA = { "TPRegexp::$" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TPMERegexp = { "TPMERegexp" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStringToken = { "TStringToken" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TExMap = { "TExMap" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TBits = { "TBits" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TProcessUUID = { "TProcessUUID" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TDictionary = { "TDictionary" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TQClass = { "TQClass" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TQCommand = { "TQCommand" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TQUndoManager = { "TQUndoManager" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TQSlot = { "TQSlot" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TRef = { "TRef" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TRefcLcLdA = { "TRef::$" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TRegexpcLcLEStatVal = { "TRegexp::EStatVal" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TSystemFile = { "TSystemFile" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TOrdCollection = { "TOrdCollection" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSystemDirectory = { "TSystemDirectory" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSystem = { "TSystem" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator = { "vector<TString,allocator<TString> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSysEvtHandler = { "TSysEvtHandler" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TFileHandler = { "TFileHandler" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_ESignals = { "ESignals" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_exception = { "exception" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStdExceptionHandler = { "TStdExceptionHandler" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStdExceptionHandlercLcLEStatus = { "TStdExceptionHandler::EStatus" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TTime = { "TTime" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TFdSet = { "TFdSet" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_EAccessMode = { "EAccessMode" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_ELogLevel = { "ELogLevel" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_ELogFacility = { "ELogFacility" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_ESysConstants = { "ESysConstants" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_EFpeMask = { "EFpeMask" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_EFileModeMask = { "EFileModeMask" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_FileStat_t = { "FileStat_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_UserGroup_t = { "UserGroup_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_SysInfo_t = { "SysInfo_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_CpuInfo_t = { "CpuInfo_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_MemInfo_t = { "MemInfo_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_ProcInfo_t = { "ProcInfo_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_RedirectHandle_t = { "RedirectHandle_t" , 115 , -1 };
G__linked_taginfo G__G__Base2LN_TProcessEventTimer = { "TProcessEventTimer" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TSystemcLcLEAclicMode = { "TSystem::EAclicMode" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TSystemcLcLEAclicProperties = { "TSystem::EAclicProperties" , 101 , -1 };
G__linked_taginfo G__G__Base2LN_TRemoteObject = { "TRemoteObject" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TDataType = { "TDataType" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TStyle = { "TStyle" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TInterpreter = { "TInterpreter" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TGlobal = { "TGlobal" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TClassGenerator = { "TClassGenerator" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TROOT = { "TROOT" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_TTask = { "TTask" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator = { "vector<string,allocator<string> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Base2() {
  G__G__Base2LN_type_info.tagnum = -1 ;
  G__G__Base2LN_TClass.tagnum = -1 ;
  G__G__Base2LN_TBuffer.tagnum = -1 ;
  G__G__Base2LN_TDirectory.tagnum = -1 ;
  G__G__Base2LN_TMemberInspector.tagnum = -1 ;
  G__G__Base2LN_TObject.tagnum = -1 ;
  G__G__Base2LN_TNamed.tagnum = -1 ;
  G__G__Base2LN_TString.tagnum = -1 ;
  G__G__Base2LN_TVirtualIsAProxy.tagnum = -1 ;
  G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Base2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Base2LN_string.tagnum = -1 ;
  G__G__Base2LN_stringcLcLiterator.tagnum = -1 ;
  G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR.tagnum = -1 ;
  G__G__Base2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Base2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base2LN_TStorage.tagnum = -1 ;
  G__G__Base2LN_va_list.tagnum = -1 ;
  G__G__Base2LN_TList.tagnum = -1 ;
  G__G__Base2LN_TBrowser.tagnum = -1 ;
  G__G__Base2LN_TObjArray.tagnum = -1 ;
  G__G__Base2LN_TMethod.tagnum = -1 ;
  G__G__Base2LN_TTimer.tagnum = -1 ;
  G__G__Base2LN_TObjectcLcLEStatusBits.tagnum = -1 ;
  G__G__Base2LN_TObjectcLcLdA.tagnum = -1 ;
  G__G__Base2LN_TProcessID.tagnum = -1 ;
  G__G__Base2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Base2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base2LN_TMemberInspectorcLcLTParentBuf.tagnum = -1 ;
  G__G__Base2LN_TRefCnt.tagnum = -1 ;
  G__G__Base2LN_TRefCntcLcLEReferenceFlag.tagnum = -1 ;
  G__G__Base2LN_TRegexp.tagnum = -1 ;
  G__G__Base2LN_TPRegexp.tagnum = -1 ;
  G__G__Base2LN_TSubString.tagnum = -1 ;
  G__G__Base2LN_TStringRef.tagnum = -1 ;
  G__G__Base2LN_TStringLong.tagnum = -1 ;
  G__G__Base2LN_TStringcLcLEStripType.tagnum = -1 ;
  G__G__Base2LN_TStringcLcLECaseCompare.tagnum = -1 ;
  G__G__Base2LN_TQConnection.tagnum = -1 ;
  G__G__Base2LN_TQObject.tagnum = -1 ;
  G__G__Base2LN_TQObjSender.tagnum = -1 ;
  G__G__Base2LN_TSignalHandler.tagnum = -1 ;
  G__G__Base2LN_TApplication.tagnum = -1 ;
  G__G__Base2LN_TStopwatch.tagnum = -1 ;
  G__G__Base2LN_TStopwatchcLcLEState.tagnum = -1 ;
  G__G__Base2LN_TCanvas.tagnum = -1 ;
  G__G__Base2LN_TArrayI.tagnum = -1 ;
  G__G__Base2LN_TColor.tagnum = -1 ;
  G__G__Base2LN_TFunction.tagnum = -1 ;
  G__G__Base2LN_TVirtualPad.tagnum = -1 ;
  G__G__Base2LN_TDatime.tagnum = -1 ;
  G__G__Base2LN_TCollection.tagnum = -1 ;
  G__G__Base2LN_TSeqCollection.tagnum = -1 ;
  G__G__Base2LN_TObjLink.tagnum = -1 ;
  G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Base2LN_TFile.tagnum = -1 ;
  G__G__Base2LN_TInetAddress.tagnum = -1 ;
  G__G__Base2LN_TUUID.tagnum = -1 ;
  G__G__Base2LN_TUUIDcLcLuuid_time_t.tagnum = -1 ;
  G__G__Base2LN_TEnv.tagnum = -1 ;
  G__G__Base2LN_TExec.tagnum = -1 ;
  G__G__Base2LN_TFolder.tagnum = -1 ;
  G__G__Base2LN_TObjString.tagnum = -1 ;
  G__G__Base2LN_TMD5.tagnum = -1 ;
  G__G__Base2LN_TMacro.tagnum = -1 ;
  G__G__Base2LN_TMessageHandler.tagnum = -1 ;
  G__G__Base2LN_THashTable.tagnum = -1 ;
  G__G__Base2LN_TMethodCall.tagnum = -1 ;
  G__G__Base2LN_TPluginManager.tagnum = -1 ;
  G__G__Base2LN_TPluginHandler.tagnum = -1 ;
  G__G__Base2LN_TPoint.tagnum = -1 ;
  G__G__Base2LN_PCREPriv_t.tagnum = -1 ;
  G__G__Base2LN_TPRegexpcLcLdA.tagnum = -1 ;
  G__G__Base2LN_TPMERegexp.tagnum = -1 ;
  G__G__Base2LN_TStringToken.tagnum = -1 ;
  G__G__Base2LN_TExMap.tagnum = -1 ;
  G__G__Base2LN_TBits.tagnum = -1 ;
  G__G__Base2LN_TProcessUUID.tagnum = -1 ;
  G__G__Base2LN_TDictionary.tagnum = -1 ;
  G__G__Base2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__Base2LN_TQClass.tagnum = -1 ;
  G__G__Base2LN_TQCommand.tagnum = -1 ;
  G__G__Base2LN_TQUndoManager.tagnum = -1 ;
  G__G__Base2LN_TQSlot.tagnum = -1 ;
  G__G__Base2LN_TRef.tagnum = -1 ;
  G__G__Base2LN_TRefcLcLdA.tagnum = -1 ;
  G__G__Base2LN_TRegexpcLcLEStatVal.tagnum = -1 ;
  G__G__Base2LN_TSystemFile.tagnum = -1 ;
  G__G__Base2LN_TOrdCollection.tagnum = -1 ;
  G__G__Base2LN_TSystemDirectory.tagnum = -1 ;
  G__G__Base2LN_TSystem.tagnum = -1 ;
  G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__Base2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Base2LN_TSysEvtHandler.tagnum = -1 ;
  G__G__Base2LN_TFileHandler.tagnum = -1 ;
  G__G__Base2LN_ESignals.tagnum = -1 ;
  G__G__Base2LN_exception.tagnum = -1 ;
  G__G__Base2LN_TStdExceptionHandler.tagnum = -1 ;
  G__G__Base2LN_TStdExceptionHandlercLcLEStatus.tagnum = -1 ;
  G__G__Base2LN_TTime.tagnum = -1 ;
  G__G__Base2LN_TFdSet.tagnum = -1 ;
  G__G__Base2LN_EAccessMode.tagnum = -1 ;
  G__G__Base2LN_ELogLevel.tagnum = -1 ;
  G__G__Base2LN_ELogFacility.tagnum = -1 ;
  G__G__Base2LN_ESysConstants.tagnum = -1 ;
  G__G__Base2LN_EFpeMask.tagnum = -1 ;
  G__G__Base2LN_EFileModeMask.tagnum = -1 ;
  G__G__Base2LN_FileStat_t.tagnum = -1 ;
  G__G__Base2LN_UserGroup_t.tagnum = -1 ;
  G__G__Base2LN_SysInfo_t.tagnum = -1 ;
  G__G__Base2LN_CpuInfo_t.tagnum = -1 ;
  G__G__Base2LN_MemInfo_t.tagnum = -1 ;
  G__G__Base2LN_ProcInfo_t.tagnum = -1 ;
  G__G__Base2LN_RedirectHandle_t.tagnum = -1 ;
  G__G__Base2LN_TProcessEventTimer.tagnum = -1 ;
  G__G__Base2LN_TSystemcLcLEAclicMode.tagnum = -1 ;
  G__G__Base2LN_TSystemcLcLEAclicProperties.tagnum = -1 ;
  G__G__Base2LN_TRemoteObject.tagnum = -1 ;
  G__G__Base2LN_TDataType.tagnum = -1 ;
  G__G__Base2LN_TStyle.tagnum = -1 ;
  G__G__Base2LN_TInterpreter.tagnum = -1 ;
  G__G__Base2LN_TGlobal.tagnum = -1 ;
  G__G__Base2LN_TClassGenerator.tagnum = -1 ;
  G__G__Base2LN_TROOT.tagnum = -1 ;
  G__G__Base2LN_TTask.tagnum = -1 ;
  G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Base2() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Base2LN_type_info);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TDirectory);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TMemberInspector),sizeof(TMemberInspector),-1,1281,"ABC for inspecting class data members",G__setup_memvarTMemberInspector,G__setup_memfuncTMemberInspector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TObject),sizeof(TObject),-1,98048,"Basic ROOT object",G__setup_memvarTObject,G__setup_memfuncTObject);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TNamed),sizeof(TNamed),-1,327424,"The basis for a named object (name, title)",G__setup_memvarTNamed,G__setup_memfuncTNamed);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TString),sizeof(TString),-1,233216,"Basic string class",G__setup_memvarTString,G__setup_memfuncTString);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TVirtualIsAProxy);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_string),sizeof(string),-1,36608,(char*)NULL,G__setup_memvarstring,G__setup_memfuncstring);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_stringcLcLiterator),sizeof(string::iterator),-1,33024,(char*)NULL,G__setup_memvarstringcLcLiterator,G__setup_memfuncstringcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_reverse_iteratorlEstringcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TStorage),sizeof(TStorage),-1,1024,"Storage manager class",G__setup_memvarTStorage,G__setup_memfuncTStorage);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_va_list);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TMethod);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TTimer),sizeof(TTimer),-1,65280,"Handle timer event",G__setup_memvarTTimer,G__setup_memfuncTTimer);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TObjectcLcLEStatusBits);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TObjectcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TProcessID),sizeof(TProcessID),-1,327424,"Process Unique Identifier in time and space",G__setup_memvarTProcessID,G__setup_memfuncTProcessID);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TMemberInspectorcLcLTParentBuf);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TRefCnt),sizeof(TRefCnt),-1,34048,(char*)NULL,G__setup_memvarTRefCnt,G__setup_memfuncTRefCnt);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TRefCntcLcLEReferenceFlag);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TRegexp),sizeof(TRegexp),-1,36352,"Regular expression class",G__setup_memvarTRegexp,G__setup_memfuncTRegexp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TPRegexp),sizeof(TPRegexp),-1,36608,"Perl Compatible Regular Expression Class",G__setup_memvarTPRegexp,G__setup_memfuncTPRegexp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TSubString),sizeof(TSubString),-1,35328,(char*)NULL,G__setup_memvarTSubString,G__setup_memfuncTSubString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TStringRef),sizeof(TStringRef),-1,229376,(char*)NULL,G__setup_memvarTStringRef,G__setup_memfuncTStringRef);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TStringLong),sizeof(TStringLong),-1,99584,"Long string class (more than 255 chars)",G__setup_memvarTStringLong,G__setup_memfuncTStringLong);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TStringcLcLEStripType);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TStringcLcLECaseCompare);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TQConnection),sizeof(TQConnection),-1,63232,"Internal class used in the object communication mechanism",G__setup_memvarTQConnection,G__setup_memfuncTQConnection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TQObject),sizeof(TQObject),-1,69376,"Base class for object communication mechanism",G__setup_memvarTQObject,G__setup_memfuncTQObject);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TQObjSender),sizeof(TQObjSender),-1,3840,"Used to \"delegate\" TQObject functionality",G__setup_memvarTQObjSender,G__setup_memfuncTQObjSender);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TSignalHandler),sizeof(TSignalHandler),-1,62720,"Signal event handler",G__setup_memvarTSignalHandler,G__setup_memfuncTSignalHandler);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TApplication);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TStopwatch),sizeof(TStopwatch),-1,291072,"A stopwatch which times real and cpu time",G__setup_memvarTStopwatch,G__setup_memfuncTStopwatch);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TStopwatchcLcLEState);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TCanvas);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TArrayI);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TColor);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TFunction);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TDatime);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TCollection);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TSeqCollection);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TObjLink);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TFile);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TInetAddress);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TUUID),sizeof(TUUID),-1,296192,"Universally Unique IDentifier",G__setup_memvarTUUID,G__setup_memfuncTUUID);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TUUIDcLcLuuid_time_t);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TEnv);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TExec),sizeof(TExec),-1,325376,"To execute a CINT command",G__setup_memvarTExec,G__setup_memfuncTExec);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TFolder),sizeof(TFolder),-1,327424,"Describe a folder: a list of objects and folders",G__setup_memvarTFolder,G__setup_memfuncTFolder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TObjString),sizeof(TObjString),-1,292608,"Collectable string class",G__setup_memvarTObjString,G__setup_memfuncTObjString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TMD5),sizeof(TMD5),-1,298752,"MD5 cryptographic hash functions with a 128 bit output",G__setup_memvarTMD5,G__setup_memfuncTMD5);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TMacro),sizeof(TMacro),-1,327424,"Class supporting a collection of lines with C++ code.",G__setup_memvarTMacro,G__setup_memfuncTMacro);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TMessageHandler),sizeof(TMessageHandler),-1,324608,"Generic message handler",G__setup_memvarTMessageHandler,G__setup_memfuncTMessageHandler);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_THashTable);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TMethodCall);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TPluginManager),sizeof(TPluginManager),-1,32512,"Manager for plugin handlers",G__setup_memvarTPluginManager,G__setup_memfuncTPluginManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TPluginHandler),sizeof(TPluginHandler),-1,65280,"Handler for plugin libraries",G__setup_memvarTPluginHandler,G__setup_memfuncTPluginHandler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TPoint),sizeof(TPoint),-1,36096,(char*)NULL,G__setup_memvarTPoint,G__setup_memfuncTPoint);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_PCREPriv_t);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TPRegexpcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TPMERegexp),sizeof(TPMERegexp),-1,36608,"Wrapper for Perl-like regular expression matching.",G__setup_memvarTPMERegexp,G__setup_memfuncTPMERegexp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TStringToken),sizeof(TStringToken),-1,33792,"String tokenizer using PCRE for finding next tokens.",G__setup_memvarTStringToken,G__setup_memfuncTStringToken);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TExMap);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TProcessUUID),sizeof(TProcessUUID),-1,326912,"TProcessID managing UUIDs",G__setup_memvarTProcessUUID,G__setup_memfuncTProcessUUID);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TDictionary);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TQClass),sizeof(TQClass),-1,64512,"Class with connections",G__setup_memvarTQClass,G__setup_memfuncTQClass);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TQCommand),sizeof(TQCommand),-1,63232,"encapsulates the information for undo/redo a single action.",G__setup_memvarTQCommand,G__setup_memfuncTQCommand);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TQUndoManager),sizeof(TQUndoManager),-1,62720,"recorder of operations for undo and redo",G__setup_memvarTQUndoManager,G__setup_memfuncTQUndoManager);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TQSlot);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TRef),sizeof(TRef),-1,130816,"Persistent Reference link to a TObject",G__setup_memvarTRef,G__setup_memfuncTRef);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TRefcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TRegexpcLcLEStatVal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TSystemFile),sizeof(TSystemFile),-1,324864,"A system file",G__setup_memvarTSystemFile,G__setup_memfuncTSystemFile);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TOrdCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TSystemDirectory),sizeof(TSystemDirectory),-1,327424,"A system directory",G__setup_memvarTSystemDirectory,G__setup_memfuncTSystemDirectory);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TSystem),sizeof(TSystem),-1,327424,"ABC defining a generic interface to the OS",G__setup_memvarTSystem,G__setup_memfuncTSystem);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgR),sizeof(vector<TString,allocator<TString> >),-1,36608,(char*)NULL,G__setup_memvarvectorlETStringcOallocatorlETStringgRsPgR,G__setup_memfuncvectorlETStringcOallocatorlETStringgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlETStringcOallocatorlETStringgRsPgRcLcLiterator),sizeof(vector<TString,allocator<TString> >::iterator),-1,35072,(char*)NULL,G__setup_memvarvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator,G__setup_memfuncvectorlETStringcOallocatorlETStringgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),sizeof(reverse_iterator<vector<TString,allocator<TString> >::iterator>),-1,256,(char*)NULL,G__setup_memvarreverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR,G__setup_memfuncreverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TSysEvtHandler),sizeof(TSysEvtHandler),-1,29955,"ABC for handling system events",G__setup_memvarTSysEvtHandler,G__setup_memfuncTSysEvtHandler);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TFileHandler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_ESignals),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_exception);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TStdExceptionHandler),sizeof(TStdExceptionHandler),-1,29953,"C++ exception handler",G__setup_memvarTStdExceptionHandler,G__setup_memfuncTStdExceptionHandler);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TStdExceptionHandlercLcLEStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TTime),sizeof(TTime),-1,36608,"Basic time type with milli second precision",G__setup_memvarTTime,G__setup_memfuncTTime);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TFdSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_EAccessMode),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_ELogLevel);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_ELogFacility);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_ESysConstants),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_EFpeMask),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_EFileModeMask),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_FileStat_t),sizeof(FileStat_t),-1,256,(char*)NULL,G__setup_memvarFileStat_t,G__setup_memfuncFileStat_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_UserGroup_t),sizeof(UserGroup_t),-1,256,(char*)NULL,G__setup_memvarUserGroup_t,G__setup_memfuncUserGroup_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_SysInfo_t),sizeof(SysInfo_t),-1,1280,"System information - OS, CPU, RAM.",G__setup_memvarSysInfo_t,G__setup_memfuncSysInfo_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_CpuInfo_t),sizeof(CpuInfo_t),-1,1280,"CPU load information.",G__setup_memvarCpuInfo_t,G__setup_memfuncCpuInfo_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_MemInfo_t),sizeof(MemInfo_t),-1,1280,"Memory utilization information.",G__setup_memvarMemInfo_t,G__setup_memfuncMemInfo_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_ProcInfo_t),sizeof(ProcInfo_t),-1,1280,"System resource usage of given process.",G__setup_memvarProcInfo_t,G__setup_memfuncProcInfo_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_RedirectHandle_t),sizeof(RedirectHandle_t),-1,256,(char*)NULL,G__setup_memvarRedirectHandle_t,G__setup_memfuncRedirectHandle_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TProcessEventTimer),sizeof(TProcessEventTimer),-1,61440,"Process pending events at fixed time intervals",G__setup_memvarTProcessEventTimer,G__setup_memfuncTProcessEventTimer);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TSystemcLcLEAclicMode);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TSystemcLcLEAclicProperties);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TRemoteObject),sizeof(TRemoteObject),-1,128256,"A remote object",G__setup_memvarTRemoteObject,G__setup_memfuncTRemoteObject);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TDataType);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TStyle);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TInterpreter);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TGlobal);
   G__get_linked_tagnum_fwd(&G__G__Base2LN_TClassGenerator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TROOT),sizeof(TROOT),-1,65280,"Top level (or root) structure for all classes",G__setup_memvarTROOT,G__setup_memfuncTROOT);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_TTask),sizeof(TTask),-1,327424,"Base class for tasks",G__setup_memvarTTask,G__setup_memfuncTTask);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgR),sizeof(vector<string,allocator<string> >),-1,36608,(char*)NULL,G__setup_memvarvectorlEstringcOallocatorlEstringgRsPgR,G__setup_memfuncvectorlEstringcOallocatorlEstringgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_vectorlEstringcOallocatorlEstringgRsPgRcLcLiterator),sizeof(vector<string,allocator<string> >::iterator),-1,35072,(char*)NULL,G__setup_memvarvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator,G__setup_memfuncvectorlEstringcOallocatorlEstringgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Base2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),sizeof(reverse_iterator<vector<string,allocator<string> >::iterator>),-1,256,(char*)NULL,G__setup_memvarreverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR,G__setup_memfuncreverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setupG__Base2(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Base2()");
  G__set_cpp_environmentG__Base2();
  G__cpp_setup_tagtableG__Base2();

  G__cpp_setup_inheritanceG__Base2();

  G__cpp_setup_typetableG__Base2();

  G__cpp_setup_memvarG__Base2();

  G__cpp_setup_memfuncG__Base2();
  G__cpp_setup_globalG__Base2();
  G__cpp_setup_funcG__Base2();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Base2();
  return;
}
class G__cpp_setup_initG__Base2 {
  public:
    G__cpp_setup_initG__Base2() { G__add_setup_func("G__Base2",(G__incsetup)(&G__cpp_setupG__Base2)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Base2() { G__remove_setup_func("G__Base2"); }
};
G__cpp_setup_initG__Base2 G__cpp_setup_initializerG__Base2;

---