G__Gui1.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:39:34 2011

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

#define R__DICTIONARY_FILENAME guidIguidIsrcdIG__Gui1
#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__Gui1.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 TGClient_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGClient(void *p = 0);
   static void *newArray_TGClient(Long_t size, void *p);
   static void delete_TGClient(void *p);
   static void deleteArray_TGClient(void *p);
   static void destruct_TGClient(void *p);
   static void streamer_TGClient(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGClient*)
   {
      ::TGClient *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGClient >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGClient", ::TGClient::Class_Version(), "include/TGClient.h", 54,
                  typeid(::TGClient), DefineBehavior(ptr, ptr),
                  &::TGClient::Dictionary, isa_proxy, 0,
                  sizeof(::TGClient) );
      instance.SetNew(&new_TGClient);
      instance.SetNewArray(&newArray_TGClient);
      instance.SetDelete(&delete_TGClient);
      instance.SetDeleteArray(&deleteArray_TGClient);
      instance.SetDestructor(&destruct_TGClient);
      instance.SetStreamerFunc(&streamer_TGClient);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGClient*)
   {
      return GenerateInitInstanceLocal((::TGClient*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGClient*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGObject(void *p = 0);
   static void *newArray_TGObject(Long_t size, void *p);
   static void delete_TGObject(void *p);
   static void deleteArray_TGObject(void *p);
   static void destruct_TGObject(void *p);
   static void streamer_TGObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGObject*)
   {
      ::TGObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGObject", ::TGObject::Class_Version(), "include/TGObject.h", 36,
                  typeid(::TGObject), DefineBehavior(ptr, ptr),
                  &::TGObject::Dictionary, isa_proxy, 0,
                  sizeof(::TGObject) );
      instance.SetNew(&new_TGObject);
      instance.SetNewArray(&newArray_TGObject);
      instance.SetDelete(&delete_TGObject);
      instance.SetDeleteArray(&deleteArray_TGObject);
      instance.SetDestructor(&destruct_TGObject);
      instance.SetStreamerFunc(&streamer_TGObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGObject*)
   {
      return GenerateInitInstanceLocal((::TGObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGWindow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGWindow(void *p = 0);
   static void *newArray_TGWindow(Long_t size, void *p);
   static void delete_TGWindow(void *p);
   static void deleteArray_TGWindow(void *p);
   static void destruct_TGWindow(void *p);
   static void streamer_TGWindow(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGWindow*)
   {
      ::TGWindow *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGWindow >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGWindow", ::TGWindow::Class_Version(), "include/TGWindow.h", 38,
                  typeid(::TGWindow), DefineBehavior(ptr, ptr),
                  &::TGWindow::Dictionary, isa_proxy, 0,
                  sizeof(::TGWindow) );
      instance.SetNew(&new_TGWindow);
      instance.SetNewArray(&newArray_TGWindow);
      instance.SetDelete(&delete_TGWindow);
      instance.SetDeleteArray(&deleteArray_TGWindow);
      instance.SetDestructor(&destruct_TGWindow);
      instance.SetStreamerFunc(&streamer_TGWindow);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGWindow*)
   {
      return GenerateInitInstanceLocal((::TGWindow*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGWindow*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGPicturePool_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGPicturePool(void *p);
   static void deleteArray_TGPicturePool(void *p);
   static void destruct_TGPicturePool(void *p);
   static void streamer_TGPicturePool(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGPicture_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGPicture(void *p);
   static void deleteArray_TGPicture(void *p);
   static void destruct_TGPicture(void *p);
   static void streamer_TGPicture(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGGCPool_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGGCPool(void *p);
   static void deleteArray_TGGCPool(void *p);
   static void destruct_TGGCPool(void *p);
   static void streamer_TGGCPool(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGGC_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGGC(void *p = 0);
   static void *newArray_TGGC(Long_t size, void *p);
   static void delete_TGGC(void *p);
   static void deleteArray_TGGC(void *p);
   static void destruct_TGGC(void *p);
   static void streamer_TGGC(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGUnknownWindowHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGUnknownWindowHandler(void *p);
   static void deleteArray_TGUnknownWindowHandler(void *p);
   static void destruct_TGUnknownWindowHandler(void *p);
   static void streamer_TGUnknownWindowHandler(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGIdleHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGIdleHandler(void *p);
   static void deleteArray_TGIdleHandler(void *p);
   static void destruct_TGIdleHandler(void *p);
   static void streamer_TGIdleHandler(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSelectedPicture_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGSelectedPicture(void *p);
   static void deleteArray_TGSelectedPicture(void *p);
   static void destruct_TGSelectedPicture(void *p);
   static void streamer_TGSelectedPicture(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGDimension_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGDimension(void *p = 0);
   static void *newArray_TGDimension(Long_t size, void *p);
   static void delete_TGDimension(void *p);
   static void deleteArray_TGDimension(void *p);
   static void destruct_TGDimension(void *p);
   static void streamer_TGDimension(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGPosition_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGPosition(void *p = 0);
   static void *newArray_TGPosition(Long_t size, void *p);
   static void delete_TGPosition(void *p);
   static void deleteArray_TGPosition(void *p);
   static void destruct_TGPosition(void *p);
   static void streamer_TGPosition(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGPosition*)
   {
      ::TGPosition *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGPosition >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGPosition", ::TGPosition::Class_Version(), "include/TGDimension.h", 50,
                  typeid(::TGPosition), DefineBehavior(ptr, ptr),
                  &::TGPosition::Dictionary, isa_proxy, 0,
                  sizeof(::TGPosition) );
      instance.SetNew(&new_TGPosition);
      instance.SetNewArray(&newArray_TGPosition);
      instance.SetDelete(&delete_TGPosition);
      instance.SetDeleteArray(&deleteArray_TGPosition);
      instance.SetDestructor(&destruct_TGPosition);
      instance.SetStreamerFunc(&streamer_TGPosition);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGPosition*)
   {
      return GenerateInitInstanceLocal((::TGPosition*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGPosition*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLongPosition_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLongPosition(void *p = 0);
   static void *newArray_TGLongPosition(Long_t size, void *p);
   static void delete_TGLongPosition(void *p);
   static void deleteArray_TGLongPosition(void *p);
   static void destruct_TGLongPosition(void *p);
   static void streamer_TGLongPosition(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLongPosition*)
   {
      ::TGLongPosition *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLongPosition >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLongPosition", ::TGLongPosition::Class_Version(), "include/TGDimension.h", 71,
                  typeid(::TGLongPosition), DefineBehavior(ptr, ptr),
                  &::TGLongPosition::Dictionary, isa_proxy, 0,
                  sizeof(::TGLongPosition) );
      instance.SetNew(&new_TGLongPosition);
      instance.SetNewArray(&newArray_TGLongPosition);
      instance.SetDelete(&delete_TGLongPosition);
      instance.SetDeleteArray(&deleteArray_TGLongPosition);
      instance.SetDestructor(&destruct_TGLongPosition);
      instance.SetStreamerFunc(&streamer_TGLongPosition);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLongPosition*)
   {
      return GenerateInitInstanceLocal((::TGLongPosition*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLongPosition*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGInsets_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGInsets(void *p = 0);
   static void *newArray_TGInsets(Long_t size, void *p);
   static void delete_TGInsets(void *p);
   static void deleteArray_TGInsets(void *p);
   static void destruct_TGInsets(void *p);
   static void streamer_TGInsets(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGInsets*)
   {
      ::TGInsets *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGInsets >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGInsets", ::TGInsets::Class_Version(), "include/TGDimension.h", 92,
                  typeid(::TGInsets), DefineBehavior(ptr, ptr),
                  &::TGInsets::Dictionary, isa_proxy, 0,
                  sizeof(::TGInsets) );
      instance.SetNew(&new_TGInsets);
      instance.SetNewArray(&newArray_TGInsets);
      instance.SetDelete(&delete_TGInsets);
      instance.SetDeleteArray(&deleteArray_TGInsets);
      instance.SetDestructor(&destruct_TGInsets);
      instance.SetStreamerFunc(&streamer_TGInsets);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGInsets*)
   {
      return GenerateInitInstanceLocal((::TGInsets*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGInsets*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGRectangle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGRectangle(void *p = 0);
   static void *newArray_TGRectangle(Long_t size, void *p);
   static void delete_TGRectangle(void *p);
   static void deleteArray_TGRectangle(void *p);
   static void destruct_TGRectangle(void *p);
   static void streamer_TGRectangle(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGRectangle*)
   {
      ::TGRectangle *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGRectangle >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGRectangle", ::TGRectangle::Class_Version(), "include/TGDimension.h", 113,
                  typeid(::TGRectangle), DefineBehavior(ptr, ptr),
                  &::TGRectangle::Dictionary, isa_proxy, 0,
                  sizeof(::TGRectangle) );
      instance.SetNew(&new_TGRectangle);
      instance.SetNewArray(&newArray_TGRectangle);
      instance.SetDelete(&delete_TGRectangle);
      instance.SetDeleteArray(&deleteArray_TGRectangle);
      instance.SetDestructor(&destruct_TGRectangle);
      instance.SetStreamerFunc(&streamer_TGRectangle);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGRectangle*)
   {
      return GenerateInitInstanceLocal((::TGRectangle*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGRectangle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFrame(void *p = 0);
   static void *newArray_TGFrame(Long_t size, void *p);
   static void delete_TGFrame(void *p);
   static void deleteArray_TGFrame(void *p);
   static void destruct_TGFrame(void *p);
   static void streamer_TGFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFrame*)
   {
      ::TGFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFrame", ::TGFrame::Class_Version(), "include/TGFrame.h", 143,
                  typeid(::TGFrame), DefineBehavior(ptr, ptr),
                  &::TGFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGFrame) );
      instance.SetNew(&new_TGFrame);
      instance.SetNewArray(&newArray_TGFrame);
      instance.SetDelete(&delete_TGFrame);
      instance.SetDeleteArray(&deleteArray_TGFrame);
      instance.SetDestructor(&destruct_TGFrame);
      instance.SetStreamerFunc(&streamer_TGFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFrame*)
   {
      return GenerateInitInstanceLocal((::TGFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGCompositeFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGCompositeFrame(void *p = 0);
   static void *newArray_TGCompositeFrame(Long_t size, void *p);
   static void delete_TGCompositeFrame(void *p);
   static void deleteArray_TGCompositeFrame(void *p);
   static void destruct_TGCompositeFrame(void *p);
   static void streamer_TGCompositeFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGCompositeFrame*)
   {
      ::TGCompositeFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGCompositeFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGCompositeFrame", ::TGCompositeFrame::Class_Version(), "include/TGFrame.h", 362,
                  typeid(::TGCompositeFrame), DefineBehavior(ptr, ptr),
                  &::TGCompositeFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGCompositeFrame) );
      instance.SetNew(&new_TGCompositeFrame);
      instance.SetNewArray(&newArray_TGCompositeFrame);
      instance.SetDelete(&delete_TGCompositeFrame);
      instance.SetDeleteArray(&deleteArray_TGCompositeFrame);
      instance.SetDestructor(&destruct_TGCompositeFrame);
      instance.SetStreamerFunc(&streamer_TGCompositeFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGCompositeFrame*)
   {
      return GenerateInitInstanceLocal((::TGCompositeFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGCompositeFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLayoutHints_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLayoutHints(void *p = 0);
   static void *newArray_TGLayoutHints(Long_t size, void *p);
   static void delete_TGLayoutHints(void *p);
   static void deleteArray_TGLayoutHints(void *p);
   static void destruct_TGLayoutHints(void *p);
   static void streamer_TGLayoutHints(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLayoutHints*)
   {
      ::TGLayoutHints *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLayoutHints >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLayoutHints", ::TGLayoutHints::Class_Version(), "include/TGLayout.h", 63,
                  typeid(::TGLayoutHints), DefineBehavior(ptr, ptr),
                  &::TGLayoutHints::Dictionary, isa_proxy, 0,
                  sizeof(::TGLayoutHints) );
      instance.SetNew(&new_TGLayoutHints);
      instance.SetNewArray(&newArray_TGLayoutHints);
      instance.SetDelete(&delete_TGLayoutHints);
      instance.SetDeleteArray(&deleteArray_TGLayoutHints);
      instance.SetDestructor(&destruct_TGLayoutHints);
      instance.SetStreamerFunc(&streamer_TGLayoutHints);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLayoutHints*)
   {
      return GenerateInitInstanceLocal((::TGLayoutHints*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLayoutHints*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFrameElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFrameElement(void *p = 0);
   static void *newArray_TGFrameElement(Long_t size, void *p);
   static void delete_TGFrameElement(void *p);
   static void deleteArray_TGFrameElement(void *p);
   static void destruct_TGFrameElement(void *p);
   static void streamer_TGFrameElement(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFrameElement*)
   {
      ::TGFrameElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGFrameElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFrameElement", ::TGFrameElement::Class_Version(), "include/TGLayout.h", 118,
                  typeid(::TGFrameElement), DefineBehavior(ptr, ptr),
                  &::TGFrameElement::Dictionary, isa_proxy, 0,
                  sizeof(::TGFrameElement) );
      instance.SetNew(&new_TGFrameElement);
      instance.SetNewArray(&newArray_TGFrameElement);
      instance.SetDelete(&delete_TGFrameElement);
      instance.SetDeleteArray(&deleteArray_TGFrameElement);
      instance.SetDestructor(&destruct_TGFrameElement);
      instance.SetStreamerFunc(&streamer_TGFrameElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFrameElement*)
   {
      return GenerateInitInstanceLocal((::TGFrameElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFrameElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLayoutManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLayoutManager(void *p);
   static void deleteArray_TGLayoutManager(void *p);
   static void destruct_TGLayoutManager(void *p);
   static void streamer_TGLayoutManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGVerticalLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGVerticalLayout(void *p);
   static void deleteArray_TGVerticalLayout(void *p);
   static void destruct_TGVerticalLayout(void *p);
   static void streamer_TGVerticalLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGHorizontalLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGHorizontalLayout(void *p);
   static void deleteArray_TGHorizontalLayout(void *p);
   static void destruct_TGHorizontalLayout(void *p);
   static void streamer_TGHorizontalLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGRowLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGRowLayout(void *p);
   static void deleteArray_TGRowLayout(void *p);
   static void destruct_TGRowLayout(void *p);
   static void streamer_TGRowLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGColumnLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGColumnLayout(void *p);
   static void deleteArray_TGColumnLayout(void *p);
   static void destruct_TGColumnLayout(void *p);
   static void streamer_TGColumnLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMatrixLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMatrixLayout(void *p);
   static void deleteArray_TGMatrixLayout(void *p);
   static void destruct_TGMatrixLayout(void *p);
   static void streamer_TGMatrixLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTileLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGTileLayout(void *p);
   static void deleteArray_TGTileLayout(void *p);
   static void destruct_TGTileLayout(void *p);
   static void streamer_TGTileLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGListLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGListLayout(void *p);
   static void deleteArray_TGListLayout(void *p);
   static void destruct_TGListLayout(void *p);
   static void streamer_TGListLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGListDetailsLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGListDetailsLayout(void *p);
   static void deleteArray_TGListDetailsLayout(void *p);
   static void destruct_TGListDetailsLayout(void *p);
   static void streamer_TGListDetailsLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGString_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGString(void *p = 0);
   static void *newArray_TGString(Long_t size, void *p);
   static void delete_TGString(void *p);
   static void deleteArray_TGString(void *p);
   static void destruct_TGString(void *p);
   static void streamer_TGString(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGHotString_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGHotString(void *p);
   static void deleteArray_TGHotString(void *p);
   static void destruct_TGHotString(void *p);
   static void streamer_TGHotString(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTextButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextButton(void *p = 0);
   static void *newArray_TGTextButton(Long_t size, void *p);
   static void delete_TGTextButton(void *p);
   static void deleteArray_TGTextButton(void *p);
   static void destruct_TGTextButton(void *p);
   static void streamer_TGTextButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTextButton*)
   {
      ::TGTextButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTextButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTextButton", ::TGTextButton::Class_Version(), "include/TGButton.h", 140,
                  typeid(::TGTextButton), DefineBehavior(ptr, ptr),
                  &::TGTextButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGTextButton) );
      instance.SetNew(&new_TGTextButton);
      instance.SetNewArray(&newArray_TGTextButton);
      instance.SetDelete(&delete_TGTextButton);
      instance.SetDeleteArray(&deleteArray_TGTextButton);
      instance.SetDestructor(&destruct_TGTextButton);
      instance.SetStreamerFunc(&streamer_TGTextButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTextButton*)
   {
      return GenerateInitInstanceLocal((::TGTextButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTextButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGVerticalFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVerticalFrame(void *p = 0);
   static void *newArray_TGVerticalFrame(Long_t size, void *p);
   static void delete_TGVerticalFrame(void *p);
   static void deleteArray_TGVerticalFrame(void *p);
   static void destruct_TGVerticalFrame(void *p);
   static void streamer_TGVerticalFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVerticalFrame*)
   {
      ::TGVerticalFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVerticalFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVerticalFrame", ::TGVerticalFrame::Class_Version(), "include/TGFrame.h", 450,
                  typeid(::TGVerticalFrame), DefineBehavior(ptr, ptr),
                  &::TGVerticalFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGVerticalFrame) );
      instance.SetNew(&new_TGVerticalFrame);
      instance.SetNewArray(&newArray_TGVerticalFrame);
      instance.SetDelete(&delete_TGVerticalFrame);
      instance.SetDeleteArray(&deleteArray_TGVerticalFrame);
      instance.SetDestructor(&destruct_TGVerticalFrame);
      instance.SetStreamerFunc(&streamer_TGVerticalFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVerticalFrame*)
   {
      return GenerateInitInstanceLocal((::TGVerticalFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVerticalFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGHorizontalFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHorizontalFrame(void *p = 0);
   static void *newArray_TGHorizontalFrame(Long_t size, void *p);
   static void delete_TGHorizontalFrame(void *p);
   static void deleteArray_TGHorizontalFrame(void *p);
   static void destruct_TGHorizontalFrame(void *p);
   static void streamer_TGHorizontalFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGHorizontalFrame*)
   {
      ::TGHorizontalFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGHorizontalFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGHorizontalFrame", ::TGHorizontalFrame::Class_Version(), "include/TGFrame.h", 461,
                  typeid(::TGHorizontalFrame), DefineBehavior(ptr, ptr),
                  &::TGHorizontalFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGHorizontalFrame) );
      instance.SetNew(&new_TGHorizontalFrame);
      instance.SetNewArray(&newArray_TGHorizontalFrame);
      instance.SetDelete(&delete_TGHorizontalFrame);
      instance.SetDeleteArray(&deleteArray_TGHorizontalFrame);
      instance.SetDestructor(&destruct_TGHorizontalFrame);
      instance.SetStreamerFunc(&streamer_TGHorizontalFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGHorizontalFrame*)
   {
      return GenerateInitInstanceLocal((::TGHorizontalFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGHorizontalFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMainFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMainFrame(void *p = 0);
   static void *newArray_TGMainFrame(Long_t size, void *p);
   static void delete_TGMainFrame(void *p);
   static void deleteArray_TGMainFrame(void *p);
   static void destruct_TGMainFrame(void *p);
   static void streamer_TGMainFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMainFrame*)
   {
      ::TGMainFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMainFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMainFrame", ::TGMainFrame::Class_Version(), "include/TGFrame.h", 482,
                  typeid(::TGMainFrame), DefineBehavior(ptr, ptr),
                  &::TGMainFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGMainFrame) );
      instance.SetNew(&new_TGMainFrame);
      instance.SetNewArray(&newArray_TGMainFrame);
      instance.SetDelete(&delete_TGMainFrame);
      instance.SetDeleteArray(&deleteArray_TGMainFrame);
      instance.SetDestructor(&destruct_TGMainFrame);
      instance.SetStreamerFunc(&streamer_TGMainFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMainFrame*)
   {
      return GenerateInitInstanceLocal((::TGMainFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMainFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTransientFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTransientFrame(void *p = 0);
   static void *newArray_TGTransientFrame(Long_t size, void *p);
   static void delete_TGTransientFrame(void *p);
   static void deleteArray_TGTransientFrame(void *p);
   static void destruct_TGTransientFrame(void *p);
   static void streamer_TGTransientFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTransientFrame*)
   {
      ::TGTransientFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTransientFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTransientFrame", ::TGTransientFrame::Class_Version(), "include/TGFrame.h", 591,
                  typeid(::TGTransientFrame), DefineBehavior(ptr, ptr),
                  &::TGTransientFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGTransientFrame) );
      instance.SetNew(&new_TGTransientFrame);
      instance.SetNewArray(&newArray_TGTransientFrame);
      instance.SetDelete(&delete_TGTransientFrame);
      instance.SetDeleteArray(&deleteArray_TGTransientFrame);
      instance.SetDestructor(&destruct_TGTransientFrame);
      instance.SetStreamerFunc(&streamer_TGTransientFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTransientFrame*)
   {
      return GenerateInitInstanceLocal((::TGTransientFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTransientFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGGroupFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGGroupFrame(void *p = 0);
   static void *newArray_TGGroupFrame(Long_t size, void *p);
   static void delete_TGGroupFrame(void *p);
   static void deleteArray_TGGroupFrame(void *p);
   static void destruct_TGGroupFrame(void *p);
   static void streamer_TGGroupFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGGroupFrame*)
   {
      ::TGGroupFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGGroupFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGGroupFrame", ::TGGroupFrame::Class_Version(), "include/TGFrame.h", 625,
                  typeid(::TGGroupFrame), DefineBehavior(ptr, ptr),
                  &::TGGroupFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGGroupFrame) );
      instance.SetNew(&new_TGGroupFrame);
      instance.SetNewArray(&newArray_TGGroupFrame);
      instance.SetDelete(&delete_TGGroupFrame);
      instance.SetDeleteArray(&deleteArray_TGGroupFrame);
      instance.SetDestructor(&destruct_TGGroupFrame);
      instance.SetStreamerFunc(&streamer_TGGroupFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGGroupFrame*)
   {
      return GenerateInitInstanceLocal((::TGGroupFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGGroupFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGHeaderFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHeaderFrame(void *p = 0);
   static void *newArray_TGHeaderFrame(Long_t size, void *p);
   static void delete_TGHeaderFrame(void *p);
   static void deleteArray_TGHeaderFrame(void *p);
   static void destruct_TGHeaderFrame(void *p);
   static void streamer_TGHeaderFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGHeaderFrame*)
   {
      ::TGHeaderFrame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGHeaderFrame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGHeaderFrame", ::TGHeaderFrame::Class_Version(), "include/TGFrame.h", 691,
                  typeid(::TGHeaderFrame), DefineBehavior(ptr, ptr),
                  &::TGHeaderFrame::Dictionary, isa_proxy, 0,
                  sizeof(::TGHeaderFrame) );
      instance.SetNew(&new_TGHeaderFrame);
      instance.SetNewArray(&newArray_TGHeaderFrame);
      instance.SetDelete(&delete_TGHeaderFrame);
      instance.SetDeleteArray(&deleteArray_TGHeaderFrame);
      instance.SetDestructor(&destruct_TGHeaderFrame);
      instance.SetStreamerFunc(&streamer_TGHeaderFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGHeaderFrame*)
   {
      return GenerateInitInstanceLocal((::TGHeaderFrame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGHeaderFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGWidget_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGWidget(void *p = 0);
   static void *newArray_TGWidget(Long_t size, void *p);
   static void delete_TGWidget(void *p);
   static void deleteArray_TGWidget(void *p);
   static void destruct_TGWidget(void *p);
   static void streamer_TGWidget(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGWidget*)
   {
      ::TGWidget *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGWidget >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGWidget", ::TGWidget::Class_Version(), "include/TGWidget.h", 61,
                  typeid(::TGWidget), DefineBehavior(ptr, ptr),
                  &::TGWidget::Dictionary, isa_proxy, 0,
                  sizeof(::TGWidget) );
      instance.SetNew(&new_TGWidget);
      instance.SetNewArray(&newArray_TGWidget);
      instance.SetDelete(&delete_TGWidget);
      instance.SetDeleteArray(&deleteArray_TGWidget);
      instance.SetDestructor(&destruct_TGWidget);
      instance.SetStreamerFunc(&streamer_TGWidget);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGWidget*)
   {
      return GenerateInitInstanceLocal((::TGWidget*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGWidget*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGIcon_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGIcon(void *p = 0);
   static void *newArray_TGIcon(Long_t size, void *p);
   static void delete_TGIcon(void *p);
   static void deleteArray_TGIcon(void *p);
   static void destruct_TGIcon(void *p);
   static void streamer_TGIcon(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLabel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLabel(void *p = 0);
   static void *newArray_TGLabel(Long_t size, void *p);
   static void delete_TGLabel(void *p);
   static void deleteArray_TGLabel(void *p);
   static void destruct_TGLabel(void *p);
   static void streamer_TGLabel(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLabel*)
   {
      ::TGLabel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLabel >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLabel", ::TGLabel::Class_Version(), "include/TGLabel.h", 38,
                  typeid(::TGLabel), DefineBehavior(ptr, ptr),
                  &::TGLabel::Dictionary, isa_proxy, 0,
                  sizeof(::TGLabel) );
      instance.SetNew(&new_TGLabel);
      instance.SetNewArray(&newArray_TGLabel);
      instance.SetDelete(&delete_TGLabel);
      instance.SetDeleteArray(&deleteArray_TGLabel);
      instance.SetDestructor(&destruct_TGLabel);
      instance.SetStreamerFunc(&streamer_TGLabel);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLabel*)
   {
      return GenerateInitInstanceLocal((::TGLabel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLabel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGButtonGroup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGButtonGroup(void *p = 0);
   static void *newArray_TGButtonGroup(Long_t size, void *p);
   static void delete_TGButtonGroup(void *p);
   static void deleteArray_TGButtonGroup(void *p);
   static void destruct_TGButtonGroup(void *p);
   static void streamer_TGButtonGroup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGPopupMenu_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGPopupMenu(void *p = 0);
   static void *newArray_TGPopupMenu(Long_t size, void *p);
   static void delete_TGPopupMenu(void *p);
   static void deleteArray_TGPopupMenu(void *p);
   static void destruct_TGPopupMenu(void *p);
   static void streamer_TGPopupMenu(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGPopupMenu*)
   {
      ::TGPopupMenu *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGPopupMenu >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGPopupMenu", ::TGPopupMenu::Class_Version(), "include/TGMenu.h", 131,
                  typeid(::TGPopupMenu), DefineBehavior(ptr, ptr),
                  &::TGPopupMenu::Dictionary, isa_proxy, 0,
                  sizeof(::TGPopupMenu) );
      instance.SetNew(&new_TGPopupMenu);
      instance.SetNewArray(&newArray_TGPopupMenu);
      instance.SetDelete(&delete_TGPopupMenu);
      instance.SetDeleteArray(&deleteArray_TGPopupMenu);
      instance.SetDestructor(&destruct_TGPopupMenu);
      instance.SetStreamerFunc(&streamer_TGPopupMenu);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGPopupMenu*)
   {
      return GenerateInitInstanceLocal((::TGPopupMenu*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGPopupMenu*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGButton(void *p = 0);
   static void *newArray_TGButton(Long_t size, void *p);
   static void delete_TGButton(void *p);
   static void deleteArray_TGButton(void *p);
   static void destruct_TGButton(void *p);
   static void streamer_TGButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGButton*)
   {
      ::TGButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGButton", ::TGButton::Class_Version(), "include/TGButton.h", 72,
                  typeid(::TGButton), DefineBehavior(ptr, ptr),
                  &::TGButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGButton) );
      instance.SetNew(&new_TGButton);
      instance.SetNewArray(&newArray_TGButton);
      instance.SetDelete(&delete_TGButton);
      instance.SetDeleteArray(&deleteArray_TGButton);
      instance.SetDestructor(&destruct_TGButton);
      instance.SetStreamerFunc(&streamer_TGButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGButton*)
   {
      return GenerateInitInstanceLocal((::TGButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGPictureButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGPictureButton(void *p = 0);
   static void *newArray_TGPictureButton(Long_t size, void *p);
   static void delete_TGPictureButton(void *p);
   static void deleteArray_TGPictureButton(void *p);
   static void destruct_TGPictureButton(void *p);
   static void streamer_TGPictureButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGPictureButton*)
   {
      ::TGPictureButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGPictureButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGPictureButton", ::TGPictureButton::Class_Version(), "include/TGButton.h", 226,
                  typeid(::TGPictureButton), DefineBehavior(ptr, ptr),
                  &::TGPictureButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGPictureButton) );
      instance.SetNew(&new_TGPictureButton);
      instance.SetNewArray(&newArray_TGPictureButton);
      instance.SetDelete(&delete_TGPictureButton);
      instance.SetDeleteArray(&deleteArray_TGPictureButton);
      instance.SetDestructor(&destruct_TGPictureButton);
      instance.SetStreamerFunc(&streamer_TGPictureButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGPictureButton*)
   {
      return GenerateInitInstanceLocal((::TGPictureButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGPictureButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGCheckButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGCheckButton(void *p = 0);
   static void *newArray_TGCheckButton(Long_t size, void *p);
   static void delete_TGCheckButton(void *p);
   static void deleteArray_TGCheckButton(void *p);
   static void destruct_TGCheckButton(void *p);
   static void streamer_TGCheckButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGCheckButton*)
   {
      ::TGCheckButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGCheckButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGCheckButton", ::TGCheckButton::Class_Version(), "include/TGButton.h", 262,
                  typeid(::TGCheckButton), DefineBehavior(ptr, ptr),
                  &::TGCheckButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGCheckButton) );
      instance.SetNew(&new_TGCheckButton);
      instance.SetNewArray(&newArray_TGCheckButton);
      instance.SetDelete(&delete_TGCheckButton);
      instance.SetDeleteArray(&deleteArray_TGCheckButton);
      instance.SetDestructor(&destruct_TGCheckButton);
      instance.SetStreamerFunc(&streamer_TGCheckButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGCheckButton*)
   {
      return GenerateInitInstanceLocal((::TGCheckButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGCheckButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGRadioButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGRadioButton(void *p = 0);
   static void *newArray_TGRadioButton(Long_t size, void *p);
   static void delete_TGRadioButton(void *p);
   static void deleteArray_TGRadioButton(void *p);
   static void destruct_TGRadioButton(void *p);
   static void streamer_TGRadioButton(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGRadioButton*)
   {
      ::TGRadioButton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGRadioButton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGRadioButton", ::TGRadioButton::Class_Version(), "include/TGButton.h", 320,
                  typeid(::TGRadioButton), DefineBehavior(ptr, ptr),
                  &::TGRadioButton::Dictionary, isa_proxy, 0,
                  sizeof(::TGRadioButton) );
      instance.SetNew(&new_TGRadioButton);
      instance.SetNewArray(&newArray_TGRadioButton);
      instance.SetDelete(&delete_TGRadioButton);
      instance.SetDeleteArray(&deleteArray_TGRadioButton);
      instance.SetDestructor(&destruct_TGRadioButton);
      instance.SetStreamerFunc(&streamer_TGRadioButton);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGRadioButton*)
   {
      return GenerateInitInstanceLocal((::TGRadioButton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGRadioButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGSplitButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGSplitButton(void *p);
   static void deleteArray_TGSplitButton(void *p);
   static void destruct_TGSplitButton(void *p);
   static void streamer_TGSplitButton(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTextBuffer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextBuffer(void *p = 0);
   static void *newArray_TGTextBuffer(Long_t size, void *p);
   static void delete_TGTextBuffer(void *p);
   static void deleteArray_TGTextBuffer(void *p);
   static void destruct_TGTextBuffer(void *p);
   static void streamer_TGTextBuffer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTextEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextEntry(void *p = 0);
   static void *newArray_TGTextEntry(Long_t size, void *p);
   static void delete_TGTextEntry(void *p);
   static void deleteArray_TGTextEntry(void *p);
   static void destruct_TGTextEntry(void *p);
   static void streamer_TGTextEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTextEntry*)
   {
      ::TGTextEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTextEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTextEntry", ::TGTextEntry::Class_Version(), "include/TGTextEntry.h", 45,
                  typeid(::TGTextEntry), DefineBehavior(ptr, ptr),
                  &::TGTextEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGTextEntry) );
      instance.SetNew(&new_TGTextEntry);
      instance.SetNewArray(&newArray_TGTextEntry);
      instance.SetDelete(&delete_TGTextEntry);
      instance.SetDeleteArray(&deleteArray_TGTextEntry);
      instance.SetDestructor(&destruct_TGTextEntry);
      instance.SetStreamerFunc(&streamer_TGTextEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTextEntry*)
   {
      return GenerateInitInstanceLocal((::TGTextEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTextEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMsgBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMsgBox(void *p = 0);
   static void *newArray_TGMsgBox(Long_t size, void *p);
   static void delete_TGMsgBox(void *p);
   static void deleteArray_TGMsgBox(void *p);
   static void destruct_TGMsgBox(void *p);
   static void streamer_TGMsgBox(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMsgBox*)
   {
      ::TGMsgBox *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMsgBox >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMsgBox", ::TGMsgBox::Class_Version(), "include/TGMsgBox.h", 71,
                  typeid(::TGMsgBox), DefineBehavior(ptr, ptr),
                  &::TGMsgBox::Dictionary, isa_proxy, 0,
                  sizeof(::TGMsgBox) );
      instance.SetNew(&new_TGMsgBox);
      instance.SetNewArray(&newArray_TGMsgBox);
      instance.SetDelete(&delete_TGMsgBox);
      instance.SetDeleteArray(&deleteArray_TGMsgBox);
      instance.SetDestructor(&destruct_TGMsgBox);
      instance.SetStreamerFunc(&streamer_TGMsgBox);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMsgBox*)
   {
      return GenerateInitInstanceLocal((::TGMsgBox*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMsgBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMenuBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMenuBar(void *p = 0);
   static void *newArray_TGMenuBar(Long_t size, void *p);
   static void delete_TGMenuBar(void *p);
   static void deleteArray_TGMenuBar(void *p);
   static void destruct_TGMenuBar(void *p);
   static void streamer_TGMenuBar(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMenuBar*)
   {
      ::TGMenuBar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMenuBar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMenuBar", ::TGMenuBar::Class_Version(), "include/TGMenu.h", 312,
                  typeid(::TGMenuBar), DefineBehavior(ptr, ptr),
                  &::TGMenuBar::Dictionary, isa_proxy, 0,
                  sizeof(::TGMenuBar) );
      instance.SetNew(&new_TGMenuBar);
      instance.SetNewArray(&newArray_TGMenuBar);
      instance.SetDelete(&delete_TGMenuBar);
      instance.SetDeleteArray(&deleteArray_TGMenuBar);
      instance.SetDestructor(&destruct_TGMenuBar);
      instance.SetStreamerFunc(&streamer_TGMenuBar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMenuBar*)
   {
      return GenerateInitInstanceLocal((::TGMenuBar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMenuBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMenuTitle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMenuTitle(void *p = 0);
   static void *newArray_TGMenuTitle(Long_t size, void *p);
   static void delete_TGMenuTitle(void *p);
   static void deleteArray_TGMenuTitle(void *p);
   static void destruct_TGMenuTitle(void *p);
   static void streamer_TGMenuTitle(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMenuTitle*)
   {
      ::TGMenuTitle *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMenuTitle >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMenuTitle", ::TGMenuTitle::Class_Version(), "include/TGMenu.h", 256,
                  typeid(::TGMenuTitle), DefineBehavior(ptr, ptr),
                  &::TGMenuTitle::Dictionary, isa_proxy, 0,
                  sizeof(::TGMenuTitle) );
      instance.SetNew(&new_TGMenuTitle);
      instance.SetNewArray(&newArray_TGMenuTitle);
      instance.SetDelete(&delete_TGMenuTitle);
      instance.SetDeleteArray(&deleteArray_TGMenuTitle);
      instance.SetDestructor(&destruct_TGMenuTitle);
      instance.SetStreamerFunc(&streamer_TGMenuTitle);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMenuTitle*)
   {
      return GenerateInitInstanceLocal((::TGMenuTitle*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMenuTitle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGMenuEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGMenuEntry(void *p = 0);
   static void *newArray_TGMenuEntry(Long_t size, void *p);
   static void delete_TGMenuEntry(void *p);
   static void deleteArray_TGMenuEntry(void *p);
   static void destruct_TGMenuEntry(void *p);
   static void streamer_TGMenuEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGMenuEntry*)
   {
      ::TGMenuEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGMenuEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGMenuEntry", ::TGMenuEntry::Class_Version(), "include/TGMenu.h", 77,
                  typeid(::TGMenuEntry), DefineBehavior(ptr, ptr),
                  &::TGMenuEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGMenuEntry) );
      instance.SetNew(&new_TGMenuEntry);
      instance.SetNewArray(&newArray_TGMenuEntry);
      instance.SetDelete(&delete_TGMenuEntry);
      instance.SetDeleteArray(&deleteArray_TGMenuEntry);
      instance.SetDestructor(&destruct_TGMenuEntry);
      instance.SetStreamerFunc(&streamer_TGMenuEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGMenuEntry*)
   {
      return GenerateInitInstanceLocal((::TGMenuEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGMenuEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGShutterItem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGShutterItem(void *p = 0);
   static void *newArray_TGShutterItem(Long_t size, void *p);
   static void delete_TGShutterItem(void *p);
   static void deleteArray_TGShutterItem(void *p);
   static void destruct_TGShutterItem(void *p);
   static void streamer_TGShutterItem(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGShutterItem*)
   {
      ::TGShutterItem *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGShutterItem >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGShutterItem", ::TGShutterItem::Class_Version(), "include/TGShutter.h", 45,
                  typeid(::TGShutterItem), DefineBehavior(ptr, ptr),
                  &::TGShutterItem::Dictionary, isa_proxy, 0,
                  sizeof(::TGShutterItem) );
      instance.SetNew(&new_TGShutterItem);
      instance.SetNewArray(&newArray_TGShutterItem);
      instance.SetDelete(&delete_TGShutterItem);
      instance.SetDeleteArray(&deleteArray_TGShutterItem);
      instance.SetDestructor(&destruct_TGShutterItem);
      instance.SetStreamerFunc(&streamer_TGShutterItem);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGShutterItem*)
   {
      return GenerateInitInstanceLocal((::TGShutterItem*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGShutterItem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGShutter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGShutter(void *p = 0);
   static void *newArray_TGShutter(Long_t size, void *p);
   static void delete_TGShutter(void *p);
   static void deleteArray_TGShutter(void *p);
   static void destruct_TGShutter(void *p);
   static void streamer_TGShutter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGShutter*)
   {
      ::TGShutter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGShutter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGShutter", ::TGShutter::Class_Version(), "include/TGShutter.h", 75,
                  typeid(::TGShutter), DefineBehavior(ptr, ptr),
                  &::TGShutter::Dictionary, isa_proxy, 0,
                  sizeof(::TGShutter) );
      instance.SetNew(&new_TGShutter);
      instance.SetNewArray(&newArray_TGShutter);
      instance.SetDelete(&delete_TGShutter);
      instance.SetDeleteArray(&deleteArray_TGShutter);
      instance.SetDestructor(&destruct_TGShutter);
      instance.SetStreamerFunc(&streamer_TGShutter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGShutter*)
   {
      return GenerateInitInstanceLocal((::TGShutter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGShutter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGHorizontal3DLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHorizontal3DLine(void *p = 0);
   static void *newArray_TGHorizontal3DLine(Long_t size, void *p);
   static void delete_TGHorizontal3DLine(void *p);
   static void deleteArray_TGHorizontal3DLine(void *p);
   static void destruct_TGHorizontal3DLine(void *p);
   static void streamer_TGHorizontal3DLine(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGVertical3DLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVertical3DLine(void *p = 0);
   static void *newArray_TGVertical3DLine(Long_t size, void *p);
   static void delete_TGVertical3DLine(void *p);
   static void deleteArray_TGVertical3DLine(void *p);
   static void destruct_TGVertical3DLine(void *p);
   static void streamer_TGVertical3DLine(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVertical3DLine*)
   {
      ::TGVertical3DLine *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVertical3DLine >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVertical3DLine", ::TGVertical3DLine::Class_Version(), "include/TG3DLine.h", 50,
                  typeid(::TGVertical3DLine), DefineBehavior(ptr, ptr),
                  &::TGVertical3DLine::Dictionary, isa_proxy, 0,
                  sizeof(::TGVertical3DLine) );
      instance.SetNew(&new_TGVertical3DLine);
      instance.SetNewArray(&newArray_TGVertical3DLine);
      instance.SetDelete(&delete_TGVertical3DLine);
      instance.SetDeleteArray(&deleteArray_TGVertical3DLine);
      instance.SetDestructor(&destruct_TGVertical3DLine);
      instance.SetStreamerFunc(&streamer_TGVertical3DLine);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVertical3DLine*)
   {
      return GenerateInitInstanceLocal((::TGVertical3DLine*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVertical3DLine*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGProgressBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGProgressBar(void *p);
   static void deleteArray_TGProgressBar(void *p);
   static void destruct_TGProgressBar(void *p);
   static void streamer_TGProgressBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGHProgressBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHProgressBar(void *p = 0);
   static void *newArray_TGHProgressBar(Long_t size, void *p);
   static void delete_TGHProgressBar(void *p);
   static void deleteArray_TGHProgressBar(void *p);
   static void destruct_TGHProgressBar(void *p);
   static void streamer_TGHProgressBar(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGHProgressBar*)
   {
      ::TGHProgressBar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGHProgressBar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGHProgressBar", ::TGHProgressBar::Class_Version(), "include/TGProgressBar.h", 108,
                  typeid(::TGHProgressBar), DefineBehavior(ptr, ptr),
                  &::TGHProgressBar::Dictionary, isa_proxy, 0,
                  sizeof(::TGHProgressBar) );
      instance.SetNew(&new_TGHProgressBar);
      instance.SetNewArray(&newArray_TGHProgressBar);
      instance.SetDelete(&delete_TGHProgressBar);
      instance.SetDeleteArray(&deleteArray_TGHProgressBar);
      instance.SetDestructor(&destruct_TGHProgressBar);
      instance.SetStreamerFunc(&streamer_TGHProgressBar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGHProgressBar*)
   {
      return GenerateInitInstanceLocal((::TGHProgressBar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGHProgressBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGVProgressBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVProgressBar(void *p = 0);
   static void *newArray_TGVProgressBar(Long_t size, void *p);
   static void delete_TGVProgressBar(void *p);
   static void deleteArray_TGVProgressBar(void *p);
   static void destruct_TGVProgressBar(void *p);
   static void streamer_TGVProgressBar(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVProgressBar*)
   {
      ::TGVProgressBar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVProgressBar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVProgressBar", ::TGVProgressBar::Class_Version(), "include/TGProgressBar.h", 136,
                  typeid(::TGVProgressBar), DefineBehavior(ptr, ptr),
                  &::TGVProgressBar::Dictionary, isa_proxy, 0,
                  sizeof(::TGVProgressBar) );
      instance.SetNew(&new_TGVProgressBar);
      instance.SetNewArray(&newArray_TGVProgressBar);
      instance.SetDelete(&delete_TGVProgressBar);
      instance.SetDeleteArray(&deleteArray_TGVProgressBar);
      instance.SetDestructor(&destruct_TGVProgressBar);
      instance.SetStreamerFunc(&streamer_TGVProgressBar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVProgressBar*)
   {
      return GenerateInitInstanceLocal((::TGVProgressBar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVProgressBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGVButtonGroup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGVButtonGroup(void *p);
   static void deleteArray_TGVButtonGroup(void *p);
   static void destruct_TGVButtonGroup(void *p);
   static void streamer_TGVButtonGroup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGHButtonGroup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGHButtonGroup(void *p);
   static void deleteArray_TGHButtonGroup(void *p);
   static void destruct_TGHButtonGroup(void *p);
   static void streamer_TGHButtonGroup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGNumberFormat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGNumberFormat(void *p = 0);
   static void *newArray_TGNumberFormat(Long_t size, void *p);
   static void delete_TGNumberFormat(void *p);
   static void deleteArray_TGNumberFormat(void *p);
   static void destruct_TGNumberFormat(void *p);
   static void streamer_TGNumberFormat(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGNumberEntryField_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGNumberEntryField(void *p = 0);
   static void *newArray_TGNumberEntryField(Long_t size, void *p);
   static void delete_TGNumberEntryField(void *p);
   static void deleteArray_TGNumberEntryField(void *p);
   static void destruct_TGNumberEntryField(void *p);
   static void streamer_TGNumberEntryField(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGNumberEntryField*)
   {
      ::TGNumberEntryField *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGNumberEntryField >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGNumberEntryField", ::TGNumberEntryField::Class_Version(), "include/TGNumberEntry.h", 80,
                  typeid(::TGNumberEntryField), DefineBehavior(ptr, ptr),
                  &::TGNumberEntryField::Dictionary, isa_proxy, 0,
                  sizeof(::TGNumberEntryField) );
      instance.SetNew(&new_TGNumberEntryField);
      instance.SetNewArray(&newArray_TGNumberEntryField);
      instance.SetDelete(&delete_TGNumberEntryField);
      instance.SetDeleteArray(&deleteArray_TGNumberEntryField);
      instance.SetDestructor(&destruct_TGNumberEntryField);
      instance.SetStreamerFunc(&streamer_TGNumberEntryField);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGNumberEntryField*)
   {
      return GenerateInitInstanceLocal((::TGNumberEntryField*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGNumberEntryField*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGNumberEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGNumberEntry(void *p = 0);
   static void *newArray_TGNumberEntry(Long_t size, void *p);
   static void delete_TGNumberEntry(void *p);
   static void deleteArray_TGNumberEntry(void *p);
   static void destruct_TGNumberEntry(void *p);
   static void streamer_TGNumberEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGNumberEntry*)
   {
      ::TGNumberEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGNumberEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGNumberEntry", ::TGNumberEntry::Class_Version(), "include/TGNumberEntry.h", 163,
                  typeid(::TGNumberEntry), DefineBehavior(ptr, ptr),
                  &::TGNumberEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGNumberEntry) );
      instance.SetNew(&new_TGNumberEntry);
      instance.SetNewArray(&newArray_TGNumberEntry);
      instance.SetDelete(&delete_TGNumberEntry);
      instance.SetDeleteArray(&deleteArray_TGNumberEntry);
      instance.SetDestructor(&destruct_TGNumberEntry);
      instance.SetStreamerFunc(&streamer_TGNumberEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGNumberEntry*)
   {
      return GenerateInitInstanceLocal((::TGNumberEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGNumberEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGNumberEntryLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGNumberEntryLayout(void *p);
   static void deleteArray_TGNumberEntryLayout(void *p);
   static void destruct_TGNumberEntryLayout(void *p);
   static void streamer_TGNumberEntryLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTableLayoutHints_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGTableLayoutHints(void *p);
   static void deleteArray_TGTableLayoutHints(void *p);
   static void destruct_TGTableLayoutHints(void *p);
   static void streamer_TGTableLayoutHints(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTableLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGTableLayout(void *p);
   static void deleteArray_TGTableLayout(void *p);
   static void destruct_TGTableLayout(void *p);
   static void streamer_TGTableLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGInputDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGInputDialog(void *p = 0);
   static void *newArray_TGInputDialog(Long_t size, void *p);
   static void delete_TGInputDialog(void *p);
   static void deleteArray_TGInputDialog(void *p);
   static void destruct_TGInputDialog(void *p);
   static void streamer_TGInputDialog(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGFrameElementPack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGFrameElementPack(void *p);
   static void deleteArray_TGFrameElementPack(void *p);
   static void destruct_TGFrameElementPack(void *p);
   static void streamer_TGFrameElementPack(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGPack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGPack(void *p = 0);
   static void *newArray_TGPack(Long_t size, void *p);
   static void delete_TGPack(void *p);
   static void deleteArray_TGPack(void *p);
   static void destruct_TGPack(void *p);
   static void streamer_TGPack(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGPack*)
   {
      ::TGPack *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGPack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGPack", ::TGPack::Class_Version(), "include/TGPack.h", 40,
                  typeid(::TGPack), DefineBehavior(ptr, ptr),
                  &::TGPack::Dictionary, isa_proxy, 0,
                  sizeof(::TGPack) );
      instance.SetNew(&new_TGPack);
      instance.SetNewArray(&newArray_TGPack);
      instance.SetDelete(&delete_TGPack);
      instance.SetDeleteArray(&deleteArray_TGPack);
      instance.SetDestructor(&destruct_TGPack);
      instance.SetStreamerFunc(&streamer_TGPack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGPack*)
   {
      return GenerateInitInstanceLocal((::TGPack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGPack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGObject(void *p) {
      return  p ? new(p) ::TGObject : new ::TGObject;
   }
   static void *newArray_TGObject(Long_t nElements, void *p) {
      return p ? new(p) ::TGObject[nElements] : new ::TGObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGObject(void *p) {
      delete ((::TGObject*)p);
   }
   static void deleteArray_TGObject(void *p) {
      delete [] ((::TGObject*)p);
   }
   static void destruct_TGObject(void *p) {
      typedef ::TGObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGObject(TBuffer &buf, void *obj) {
      ((::TGObject*)obj)->::TGObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGObject

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

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

//______________________________________________________________________________
void TGClient::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGClient.
      TClass *R__cl = ::TGClient::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackColor", &fBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForeColor", &fForeColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHilite", &fHilite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShadow", &fShadow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelBackColor", &fSelBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelForeColor", &fSelForeColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWhite", &fWhite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBlack", &fBlack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultRoot", &fDefaultRoot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRoot", &fRoot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXfd", &fXfd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResourcePool", &fResourcePool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGCPool", &fGCPool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontPool", &fFontPool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicturePool", &fPicturePool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMimeTypeList", &fMimeTypeList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultColormap", &fDefaultColormap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGlobalNeedRedraw", &fGlobalNeedRedraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForceRedraw", &fForceRedraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWlist", &fWlist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlist", &fPlist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUWHandlers", &fUWHandlers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIdleHandlers", &fIdleHandlers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaitForEvent", &fWaitForEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaitForWindow", &fWaitForWindow);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGClient(void *p) {
      return  p ? new(p) ::TGClient : new ::TGClient;
   }
   static void *newArray_TGClient(Long_t nElements, void *p) {
      return p ? new(p) ::TGClient[nElements] : new ::TGClient[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGClient(void *p) {
      delete ((::TGClient*)p);
   }
   static void deleteArray_TGClient(void *p) {
      delete [] ((::TGClient*)p);
   }
   static void destruct_TGClient(void *p) {
      typedef ::TGClient current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGClient(TBuffer &buf, void *obj) {
      ((::TGClient*)obj)->::TGClient::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGClient

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TGObject::Streamer(R__b);
      R__b >> const_cast<  TGWindow* &>( fParent );
      R__b >> fNeedRedraw;
      fName.Streamer(R__b);
      R__b >> fEditDisabled;
      R__b.CheckByteCount(R__s, R__c, TGWindow::IsA());
   } else {
      R__c = R__b.WriteVersion(TGWindow::IsA(), kTRUE);
      TGObject::Streamer(R__b);
      R__b << const_cast<  TGWindow* &>( fParent );
      R__b << fNeedRedraw;
      fName.Streamer(R__b);
      R__b << fEditDisabled;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGWindow(void *p) {
      return  p ? new(p) ::TGWindow : new ::TGWindow;
   }
   static void *newArray_TGWindow(Long_t nElements, void *p) {
      return p ? new(p) ::TGWindow[nElements] : new ::TGWindow[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGWindow(void *p) {
      delete ((::TGWindow*)p);
   }
   static void deleteArray_TGWindow(void *p) {
      delete [] ((::TGWindow*)p);
   }
   static void destruct_TGWindow(void *p) {
      typedef ::TGWindow current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGWindow(TBuffer &buf, void *obj) {
      ((::TGWindow*)obj)->::TGWindow::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGWindow

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

   TObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGPicture::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGPicture.
      TClass *R__cl = ::TGPicture::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(), "fScaled", &fScaled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMask", &fMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAttributes", (void*)&fAttributes);
      R__insp.InspectMember("PictureAttributes_t", (void*)&fAttributes, "fAttributes.", false);
      TObject::ShowMembers(R__insp);
      R__insp.GenericShowMembers("TRefCnt", ( ::TRefCnt *) (this ), false);
}

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

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

   TGPicture::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGDimension(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGDimension : new ::TGDimension;
   }
   static void *newArray_TGDimension(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGDimension[nElements] : new ::TGDimension[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGDimension(void *p) {
      delete ((::TGDimension*)p);
   }
   static void deleteArray_TGDimension(void *p) {
      delete [] ((::TGDimension*)p);
   }
   static void destruct_TGDimension(void *p) {
      typedef ::TGDimension current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGDimension(TBuffer &buf, void *obj) {
      ((::TGDimension*)obj)->::TGDimension::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGDimension

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGPosition(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGPosition : new ::TGPosition;
   }
   static void *newArray_TGPosition(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGPosition[nElements] : new ::TGPosition[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGPosition(void *p) {
      delete ((::TGPosition*)p);
   }
   static void deleteArray_TGPosition(void *p) {
      delete [] ((::TGPosition*)p);
   }
   static void destruct_TGPosition(void *p) {
      typedef ::TGPosition current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGPosition(TBuffer &buf, void *obj) {
      ((::TGPosition*)obj)->::TGPosition::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGPosition

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLongPosition(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLongPosition : new ::TGLongPosition;
   }
   static void *newArray_TGLongPosition(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLongPosition[nElements] : new ::TGLongPosition[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLongPosition(void *p) {
      delete ((::TGLongPosition*)p);
   }
   static void deleteArray_TGLongPosition(void *p) {
      delete [] ((::TGLongPosition*)p);
   }
   static void destruct_TGLongPosition(void *p) {
      typedef ::TGLongPosition current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLongPosition(TBuffer &buf, void *obj) {
      ((::TGLongPosition*)obj)->::TGLongPosition::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLongPosition

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGInsets(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGInsets : new ::TGInsets;
   }
   static void *newArray_TGInsets(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGInsets[nElements] : new ::TGInsets[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGInsets(void *p) {
      delete ((::TGInsets*)p);
   }
   static void deleteArray_TGInsets(void *p) {
      delete [] ((::TGInsets*)p);
   }
   static void destruct_TGInsets(void *p) {
      typedef ::TGInsets current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGInsets(TBuffer &buf, void *obj) {
      ((::TGInsets*)obj)->::TGInsets::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGInsets

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGRectangle(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGRectangle : new ::TGRectangle;
   }
   static void *newArray_TGRectangle(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGRectangle[nElements] : new ::TGRectangle[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGRectangle(void *p) {
      delete ((::TGRectangle*)p);
   }
   static void deleteArray_TGRectangle(void *p) {
      delete [] ((::TGRectangle*)p);
   }
   static void destruct_TGRectangle(void *p) {
      typedef ::TGRectangle current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGRectangle(TBuffer &buf, void *obj) {
      ((::TGRectangle*)obj)->::TGRectangle::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGRectangle

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

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

//______________________________________________________________________________
void TGFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFrame.
      TClass *R__cl = ::TGFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidth", &fWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinWidth", &fMinWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinHeight", &fMinHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxWidth", &fMaxWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxHeight", &fMaxHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBorderWidth", &fBorderWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackground", &fBackground);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventMask", &fEventMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDNDState", &fDNDState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFE", &fFE);
      TGWindow::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFrame(void *p) {
      return  p ? new(p) ::TGFrame : new ::TGFrame;
   }
   static void *newArray_TGFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGFrame[nElements] : new ::TGFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFrame(void *p) {
      delete ((::TGFrame*)p);
   }
   static void deleteArray_TGFrame(void *p) {
      delete [] ((::TGFrame*)p);
   }
   static void destruct_TGFrame(void *p) {
      typedef ::TGFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFrame(TBuffer &buf, void *obj) {
      ((::TGFrame*)obj)->::TGFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFrame

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

   TGFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGCompositeFrame(void *p) {
      return  p ? new(p) ::TGCompositeFrame : new ::TGCompositeFrame;
   }
   static void *newArray_TGCompositeFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGCompositeFrame[nElements] : new ::TGCompositeFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGCompositeFrame(void *p) {
      delete ((::TGCompositeFrame*)p);
   }
   static void deleteArray_TGCompositeFrame(void *p) {
      delete [] ((::TGCompositeFrame*)p);
   }
   static void destruct_TGCompositeFrame(void *p) {
      typedef ::TGCompositeFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGCompositeFrame(TBuffer &buf, void *obj) {
      ((::TGCompositeFrame*)obj)->::TGCompositeFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGCompositeFrame

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVerticalFrame(void *p) {
      return  p ? new(p) ::TGVerticalFrame : new ::TGVerticalFrame;
   }
   static void *newArray_TGVerticalFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGVerticalFrame[nElements] : new ::TGVerticalFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVerticalFrame(void *p) {
      delete ((::TGVerticalFrame*)p);
   }
   static void deleteArray_TGVerticalFrame(void *p) {
      delete [] ((::TGVerticalFrame*)p);
   }
   static void destruct_TGVerticalFrame(void *p) {
      typedef ::TGVerticalFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVerticalFrame(TBuffer &buf, void *obj) {
      ((::TGVerticalFrame*)obj)->::TGVerticalFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVerticalFrame

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHorizontalFrame(void *p) {
      return  p ? new(p) ::TGHorizontalFrame : new ::TGHorizontalFrame;
   }
   static void *newArray_TGHorizontalFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGHorizontalFrame[nElements] : new ::TGHorizontalFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHorizontalFrame(void *p) {
      delete ((::TGHorizontalFrame*)p);
   }
   static void deleteArray_TGHorizontalFrame(void *p) {
      delete [] ((::TGHorizontalFrame*)p);
   }
   static void destruct_TGHorizontalFrame(void *p) {
      typedef ::TGHorizontalFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHorizontalFrame(TBuffer &buf, void *obj) {
      ((::TGHorizontalFrame*)obj)->::TGHorizontalFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHorizontalFrame

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

   TGHorizontalFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGHeaderFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGHeaderFrame.
      TClass *R__cl = ::TGHeaderFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNColumns", &fNColumns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColHeader", &fColHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplitHeader", &fSplitHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSplitCursor", &fSplitCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverSplitter", &fOverSplitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverButton", &fOverButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastButton", &fLastButton);
      TGHorizontalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHeaderFrame(void *p) {
      return  p ? new(p) ::TGHeaderFrame : new ::TGHeaderFrame;
   }
   static void *newArray_TGHeaderFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGHeaderFrame[nElements] : new ::TGHeaderFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHeaderFrame(void *p) {
      delete ((::TGHeaderFrame*)p);
   }
   static void deleteArray_TGHeaderFrame(void *p) {
      delete [] ((::TGHeaderFrame*)p);
   }
   static void destruct_TGHeaderFrame(void *p) {
      typedef ::TGHeaderFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHeaderFrame(TBuffer &buf, void *obj) {
      ((::TGHeaderFrame*)obj)->::TGHeaderFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHeaderFrame

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMainFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMainFrame.
      TClass *R__cl = ::TGMainFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDNDTypeList", &fDNDTypeList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBindList", &fBindList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWindowName", &fWindowName);
      R__insp.InspectMember(fWindowName, "fWindowName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIconName", &fIconName);
      R__insp.InspectMember(fIconName, "fIconName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIconPixmap", &fIconPixmap);
      R__insp.InspectMember(fIconPixmap, "fIconPixmap.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResourceName", &fResourceName);
      R__insp.InspectMember(fResourceName, "fResourceName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMWMValue", &fMWMValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMWMFuncs", &fMWMFuncs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMWMInput", &fMWMInput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMX", &fWMX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMY", &fWMY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMWidth", &fWMWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMHeight", &fWMHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMMinWidth", &fWMMinWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMMinHeight", &fWMMinHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMMaxWidth", &fWMMaxWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMMaxHeight", &fWMMaxHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMWidthInc", &fWMWidthInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMHeightInc", &fWMHeightInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWMInitState", &fWMInitState);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMainFrame(void *p) {
      return  p ? new(p) ::TGMainFrame : new ::TGMainFrame;
   }
   static void *newArray_TGMainFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGMainFrame[nElements] : new ::TGMainFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMainFrame(void *p) {
      delete ((::TGMainFrame*)p);
   }
   static void deleteArray_TGMainFrame(void *p) {
      delete [] ((::TGMainFrame*)p);
   }
   static void destruct_TGMainFrame(void *p) {
      typedef ::TGMainFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMainFrame(TBuffer &buf, void *obj) {
      ((::TGMainFrame*)obj)->::TGMainFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMainFrame

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

   TGMainFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTransientFrame(void *p) {
      return  p ? new(p) ::TGTransientFrame : new ::TGTransientFrame;
   }
   static void *newArray_TGTransientFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGTransientFrame[nElements] : new ::TGTransientFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTransientFrame(void *p) {
      delete ((::TGTransientFrame*)p);
   }
   static void deleteArray_TGTransientFrame(void *p) {
      delete [] ((::TGTransientFrame*)p);
   }
   static void destruct_TGTransientFrame(void *p) {
      typedef ::TGTransientFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTransientFrame(TBuffer &buf, void *obj) {
      ((::TGTransientFrame*)obj)->::TGTransientFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTransientFrame

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGGroupFrame(void *p) {
      return  p ? new(p) ::TGGroupFrame : new ::TGGroupFrame;
   }
   static void *newArray_TGGroupFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TGGroupFrame[nElements] : new ::TGGroupFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGGroupFrame(void *p) {
      delete ((::TGGroupFrame*)p);
   }
   static void deleteArray_TGGroupFrame(void *p) {
      delete [] ((::TGGroupFrame*)p);
   }
   static void destruct_TGGroupFrame(void *p) {
      typedef ::TGGroupFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGGroupFrame(TBuffer &buf, void *obj) {
      ((::TGGroupFrame*)obj)->::TGGroupFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGGroupFrame

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFrameElement(void *p) {
      return  p ? new(p) ::TGFrameElement : new ::TGFrameElement;
   }
   static void *newArray_TGFrameElement(Long_t nElements, void *p) {
      return p ? new(p) ::TGFrameElement[nElements] : new ::TGFrameElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFrameElement(void *p) {
      delete ((::TGFrameElement*)p);
   }
   static void deleteArray_TGFrameElement(void *p) {
      delete [] ((::TGFrameElement*)p);
   }
   static void destruct_TGFrameElement(void *p) {
      typedef ::TGFrameElement current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFrameElement(TBuffer &buf, void *obj) {
      ((::TGFrameElement*)obj)->::TGFrameElement::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFrameElement

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGLayoutHints::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLayoutHints.
      TClass *R__cl = ::TGLayoutHints::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFE", &fFE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrev", &fPrev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLayoutHints", &fLayoutHints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadtop", &fPadtop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadbottom", &fPadbottom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadleft", &fPadleft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadright", &fPadright);
      TObject::ShowMembers(R__insp);
      R__insp.GenericShowMembers("TRefCnt", ( ::TRefCnt *) (this ), false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLayoutHints(void *p) {
      return  p ? new(p) ::TGLayoutHints : new ::TGLayoutHints;
   }
   static void *newArray_TGLayoutHints(Long_t nElements, void *p) {
      return p ? new(p) ::TGLayoutHints[nElements] : new ::TGLayoutHints[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLayoutHints(void *p) {
      delete ((::TGLayoutHints*)p);
   }
   static void deleteArray_TGLayoutHints(void *p) {
      delete [] ((::TGLayoutHints*)p);
   }
   static void destruct_TGLayoutHints(void *p) {
      typedef ::TGLayoutHints current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLayoutHints(TBuffer &buf, void *obj) {
      ((::TGLayoutHints*)obj)->::TGLayoutHints::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLayoutHints

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

   TGLayoutHints::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TGLayoutManager::Streamer(R__b);
}

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

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

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

   TGVerticalLayout::Streamer(R__b);
}

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

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

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

   TGVerticalLayout::Streamer(R__b);
}

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

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

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

   TGRowLayout::Streamer(R__b);
}

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

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

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

   TGLayoutManager::Streamer(R__b);
}

//______________________________________________________________________________
void TGMatrixLayout::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMatrixLayout.
      TClass *R__cl = ::TGMatrixLayout::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMain", &fMain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSep", &fSep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHints", &fHints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRows", &fRows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColumns", &fColumns);
      TGLayoutManager::ShowMembers(R__insp);
}

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

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

   TGLayoutManager::Streamer(R__b);
}

//______________________________________________________________________________
void TGTableLayout::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTableLayout.
      TClass *R__cl = ::TGTableLayout::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRow", &fRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCol", &fCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMain", &fMain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHomogeneous", &fHomogeneous);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSep", &fSep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHints", &fHints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &fNrows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcols", &fNcols);
      TGLayoutManager::ShowMembers(R__insp);
}

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

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

   TGLayoutManager::Streamer(R__b);
}

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

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

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

   TGTileLayout::Streamer(R__b);
}

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

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

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

   TGTileLayout::Streamer(R__b);
}

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

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

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

   TString::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGString(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGString : new ::TGString;
   }
   static void *newArray_TGString(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGString[nElements] : new ::TGString[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGString(void *p) {
      delete ((::TGString*)p);
   }
   static void deleteArray_TGString(void *p) {
      delete [] ((::TGString*)p);
   }
   static void destruct_TGString(void *p) {
      typedef ::TGString current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGString(TBuffer &buf, void *obj) {
      ((::TGString*)obj)->::TGString::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGString

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

   TGString::Streamer(R__b);
}

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGWidget(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGWidget : new ::TGWidget;
   }
   static void *newArray_TGWidget(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGWidget[nElements] : new ::TGWidget[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGWidget(void *p) {
      delete ((::TGWidget*)p);
   }
   static void deleteArray_TGWidget(void *p) {
      delete [] ((::TGWidget*)p);
   }
   static void destruct_TGWidget(void *p) {
      typedef ::TGWidget current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGWidget(TBuffer &buf, void *obj) {
      ((::TGWidget*)obj)->::TGWidget::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGWidget

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

   TGFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGIcon(void *p) {
      return  p ? new(p) ::TGIcon : new ::TGIcon;
   }
   static void *newArray_TGIcon(Long_t nElements, void *p) {
      return p ? new(p) ::TGIcon[nElements] : new ::TGIcon[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGIcon(void *p) {
      delete ((::TGIcon*)p);
   }
   static void deleteArray_TGIcon(void *p) {
      delete [] ((::TGIcon*)p);
   }
   static void destruct_TGIcon(void *p) {
      typedef ::TGIcon current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGIcon(TBuffer &buf, void *obj) {
      ((::TGIcon*)obj)->::TGIcon::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGIcon

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGLabel::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLabel.
      TClass *R__cl = ::TGLabel::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fText", &fText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTWidth", &fTWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTHeight", &fTHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMLeft", &fMLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMRight", &fMRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMTop", &fMTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBottom", &fMBottom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMode", &fTMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "f3DStyle", &f3DStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWrapLength", &fWrapLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFlags", &fTFlags);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextChanged", &fTextChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFont", &fFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTLayout", &fTLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasOwnFont", &fHasOwnFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisabled", &fDisabled);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLabel(void *p) {
      return  p ? new(p) ::TGLabel : new ::TGLabel;
   }
   static void *newArray_TGLabel(Long_t nElements, void *p) {
      return p ? new(p) ::TGLabel[nElements] : new ::TGLabel[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLabel(void *p) {
      delete ((::TGLabel*)p);
   }
   static void deleteArray_TGLabel(void *p) {
      delete [] ((::TGLabel*)p);
   }
   static void destruct_TGLabel(void *p) {
      typedef ::TGLabel current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLabel(TBuffer &buf, void *obj) {
      ((::TGLabel*)obj)->::TGLabel::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLabel

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

   TGFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGButton::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGButton.
      TClass *R__cl = ::TGButton::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTWidth", &fTWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTHeight", &fTHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStayDown", &fStayDown);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUserData", &fUserData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGroup", &fGroup);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGButton(void *p) {
      return  p ? new(p) ::TGButton : new ::TGButton;
   }
   static void *newArray_TGButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGButton[nElements] : new ::TGButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGButton(void *p) {
      delete ((::TGButton*)p);
   }
   static void deleteArray_TGButton(void *p) {
      delete [] ((::TGButton*)p);
   }
   static void destruct_TGButton(void *p) {
      typedef ::TGButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGButton(TBuffer &buf, void *obj) {
      ((::TGButton*)obj)->::TGButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGButton

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

   TGButton::Streamer(R__b);
}

//______________________________________________________________________________
void TGTextButton::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTextButton.
      TClass *R__cl = ::TGTextButton::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMLeft", &fMLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMRight", &fMRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMTop", &fMTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBottom", &fMBottom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMode", &fTMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWrapLength", &fWrapLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHKeycode", &fHKeycode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTLayout", &fTLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasOwnFont", &fHasOwnFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStateOn", &fStateOn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrevStateOn", &fPrevStateOn);
      TGButton::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextButton(void *p) {
      return  p ? new(p) ::TGTextButton : new ::TGTextButton;
   }
   static void *newArray_TGTextButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextButton[nElements] : new ::TGTextButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextButton(void *p) {
      delete ((::TGTextButton*)p);
   }
   static void deleteArray_TGTextButton(void *p) {
      delete [] ((::TGTextButton*)p);
   }
   static void destruct_TGTextButton(void *p) {
      typedef ::TGTextButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextButton(TBuffer &buf, void *obj) {
      ((::TGTextButton*)obj)->::TGTextButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextButton

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

   TGButton::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGPictureButton(void *p) {
      return  p ? new(p) ::TGPictureButton : new ::TGPictureButton;
   }
   static void *newArray_TGPictureButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGPictureButton[nElements] : new ::TGPictureButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGPictureButton(void *p) {
      delete ((::TGPictureButton*)p);
   }
   static void deleteArray_TGPictureButton(void *p) {
      delete [] ((::TGPictureButton*)p);
   }
   static void destruct_TGPictureButton(void *p) {
      typedef ::TGPictureButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGPictureButton(TBuffer &buf, void *obj) {
      ((::TGPictureButton*)obj)->::TGPictureButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGPictureButton

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

   TGTextButton::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGCheckButton(void *p) {
      return  p ? new(p) ::TGCheckButton : new ::TGCheckButton;
   }
   static void *newArray_TGCheckButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGCheckButton[nElements] : new ::TGCheckButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGCheckButton(void *p) {
      delete ((::TGCheckButton*)p);
   }
   static void deleteArray_TGCheckButton(void *p) {
      delete [] ((::TGCheckButton*)p);
   }
   static void destruct_TGCheckButton(void *p) {
      typedef ::TGCheckButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGCheckButton(TBuffer &buf, void *obj) {
      ((::TGCheckButton*)obj)->::TGCheckButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGCheckButton

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

   TGTextButton::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGRadioButton(void *p) {
      return  p ? new(p) ::TGRadioButton : new ::TGRadioButton;
   }
   static void *newArray_TGRadioButton(Long_t nElements, void *p) {
      return p ? new(p) ::TGRadioButton[nElements] : new ::TGRadioButton[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGRadioButton(void *p) {
      delete ((::TGRadioButton*)p);
   }
   static void deleteArray_TGRadioButton(void *p) {
      delete [] ((::TGRadioButton*)p);
   }
   static void destruct_TGRadioButton(void *p) {
      typedef ::TGRadioButton current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGRadioButton(TBuffer &buf, void *obj) {
      ((::TGRadioButton*)obj)->::TGRadioButton::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGRadioButton

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

   TGTextButton::Streamer(R__b);
}

//______________________________________________________________________________
void TGSplitButton::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGSplitButton.
      TClass *R__cl = ::TGSplitButton::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSplit", &fSplit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBState", &fMBState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTBWidth", &fTBWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBWidth", &fMBWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPopMenu", &fPopMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryId", &fEntryId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuLabel", &fMenuLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultCursor", &fDefaultCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeyNavigate", &fKeyNavigate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidestLabel", &fWidestLabel);
      R__insp.InspectMember(fWidestLabel, "fWidestLabel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeighestLabel", &fHeighestLabel);
      R__insp.InspectMember(fHeighestLabel, "fHeighestLabel.");
      TGTextButton::ShowMembers(R__insp);
}

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

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

   TGGroupFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGButtonGroup(void *p) {
      return  p ? new(p) ::TGButtonGroup : new ::TGButtonGroup;
   }
   static void *newArray_TGButtonGroup(Long_t nElements, void *p) {
      return p ? new(p) ::TGButtonGroup[nElements] : new ::TGButtonGroup[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGButtonGroup(void *p) {
      delete ((::TGButtonGroup*)p);
   }
   static void deleteArray_TGButtonGroup(void *p) {
      delete [] ((::TGButtonGroup*)p);
   }
   static void destruct_TGButtonGroup(void *p) {
      typedef ::TGButtonGroup current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGButtonGroup(TBuffer &buf, void *obj) {
      ((::TGButtonGroup*)obj)->::TGButtonGroup::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGButtonGroup

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

   TGButtonGroup::Streamer(R__b);
}

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

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

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

   TGButtonGroup::Streamer(R__b);
}

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextBuffer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGTextBuffer : new ::TGTextBuffer;
   }
   static void *newArray_TGTextBuffer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGTextBuffer[nElements] : new ::TGTextBuffer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextBuffer(void *p) {
      delete ((::TGTextBuffer*)p);
   }
   static void deleteArray_TGTextBuffer(void *p) {
      delete [] ((::TGTextBuffer*)p);
   }
   static void destruct_TGTextBuffer(void *p) {
      typedef ::TGTextBuffer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextBuffer(TBuffer &buf, void *obj) {
      ((::TGTextBuffer*)obj)->::TGTextBuffer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextBuffer

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

   TGFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGTextEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTextEntry.
      TClass *R__cl = ::TGTextEntry::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fText", &fText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartX", &fStartX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndX", &fEndX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartIX", &fStartIX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndIX", &fEndIX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectionOn", &fSelectionOn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorX", &fCursorX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorIX", &fCursorIX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorOn", &fCursorOn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.InspectMember(fNormGC, "fNormGC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelGC", &fSelGC);
      R__insp.InspectMember(fSelGC, "fSelGC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelbackGC", &fSelbackGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipboard", &fClipboard);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurBlink", &fCurBlink);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxLen", &fMaxLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEdited", &fEdited);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameDrawn", &fFrameDrawn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEchoMode", &fEchoMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInsertMode", &fInsertMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlignment", &fAlignment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasOwnFont", &fHasOwnFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefWidth", &fDefWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefHeight", &fDefHeight);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextEntry(void *p) {
      return  p ? new(p) ::TGTextEntry : new ::TGTextEntry;
   }
   static void *newArray_TGTextEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextEntry[nElements] : new ::TGTextEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextEntry(void *p) {
      delete ((::TGTextEntry*)p);
   }
   static void deleteArray_TGTextEntry(void *p) {
      delete [] ((::TGTextEntry*)p);
   }
   static void destruct_TGTextEntry(void *p) {
      typedef ::TGTextEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextEntry(TBuffer &buf, void *obj) {
      ((::TGTextEntry*)obj)->::TGTextEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextEntry

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMsgBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMsgBox.
      TClass *R__cl = ::TGMsgBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYes", &fYes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNo", &fNo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOK", &fOK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetry", &fRetry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIgnore", &fIgnore);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClose", &fClose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYesAll", &fYesAll);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNoAll", &fNoAll);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewer", &fNewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAppend", &fAppend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDismiss", &fDismiss);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIcon", &fIcon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtonFrame", &fButtonFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIconFrame", &fIconFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelFrame", &fLabelFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL1", &fL1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL2", &fL2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL3", &fL3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL4", &fL4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL5", &fL5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgList", &fMsgList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetCode", &fRetCode);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMsgBox(void *p) {
      return  p ? new(p) ::TGMsgBox : new ::TGMsgBox;
   }
   static void *newArray_TGMsgBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGMsgBox[nElements] : new ::TGMsgBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMsgBox(void *p) {
      delete ((::TGMsgBox*)p);
   }
   static void deleteArray_TGMsgBox(void *p) {
      delete [] ((::TGMsgBox*)p);
   }
   static void destruct_TGMsgBox(void *p) {
      typedef ::TGMsgBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMsgBox(TBuffer &buf, void *obj) {
      ((::TGMsgBox*)obj)->::TGMsgBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMsgBox

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

   TGTransientFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGInputDialog(void *p) {
      return  p ? new(p) ::TGInputDialog : new ::TGInputDialog;
   }
   static void *newArray_TGInputDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGInputDialog[nElements] : new ::TGInputDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGInputDialog(void *p) {
      delete ((::TGInputDialog*)p);
   }
   static void deleteArray_TGInputDialog(void *p) {
      delete [] ((::TGInputDialog*)p);
   }
   static void destruct_TGInputDialog(void *p) {
      typedef ::TGInputDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGInputDialog(TBuffer &buf, void *obj) {
      ((::TGInputDialog*)obj)->::TGInputDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGInputDialog

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

   TGHorizontalFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMenuBar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMenuBar.
      TClass *R__cl = ::TGMenuBar::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitles", &fTitles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultCursor", &fDefaultCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStick", &fStick);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrash", &fTrash);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeyNavigate", &fKeyNavigate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuMore", &fMenuMore);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarMoreLayout", &fMenuBarMoreLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWithExt", &fWithExt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutLayouts", &fOutLayouts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNeededSpace", &fNeededSpace);
      TGHorizontalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMenuBar(void *p) {
      return  p ? new(p) ::TGMenuBar : new ::TGMenuBar;
   }
   static void *newArray_TGMenuBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGMenuBar[nElements] : new ::TGMenuBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMenuBar(void *p) {
      delete ((::TGMenuBar*)p);
   }
   static void deleteArray_TGMenuBar(void *p) {
      delete [] ((::TGMenuBar*)p);
   }
   static void destruct_TGMenuBar(void *p) {
      typedef ::TGMenuBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMenuBar(TBuffer &buf, void *obj) {
      ((::TGMenuBar*)obj)->::TGMenuBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMenuBar

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGPopupMenu::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGPopupMenu.
      TClass *R__cl = ::TGPopupMenu::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryList", &fEntryList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStick", &fStick);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasGrab", &fHasGrab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoppedUp", &fPoppedUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXl", &fXl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMenuWidth", &fMenuWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMenuHeight", &fMenuHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelay", &fDelay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelGC", &fSelGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelbackGC", &fSelbackGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHifontStruct", &fHifontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultCursor", &fDefaultCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplitButton", &fSplitButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntrySep", &fEntrySep);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGPopupMenu(void *p) {
      return  p ? new(p) ::TGPopupMenu : new ::TGPopupMenu;
   }
   static void *newArray_TGPopupMenu(Long_t nElements, void *p) {
      return p ? new(p) ::TGPopupMenu[nElements] : new ::TGPopupMenu[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGPopupMenu(void *p) {
      delete ((::TGPopupMenu*)p);
   }
   static void deleteArray_TGPopupMenu(void *p) {
      delete [] ((::TGPopupMenu*)p);
   }
   static void destruct_TGPopupMenu(void *p) {
      typedef ::TGPopupMenu current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGPopupMenu(TBuffer &buf, void *obj) {
      ((::TGPopupMenu*)obj)->::TGPopupMenu::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGPopupMenu

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGMenuTitle::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMenuTitle.
      TClass *R__cl = ::TGMenuTitle::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenu", &fMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleId", &fTitleId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleData", &fTitleData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHkeycode", &fHkeycode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextColor", &fTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelGC", &fSelGC);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMenuTitle(void *p) {
      return  p ? new(p) ::TGMenuTitle : new ::TGMenuTitle;
   }
   static void *newArray_TGMenuTitle(Long_t nElements, void *p) {
      return p ? new(p) ::TGMenuTitle[nElements] : new ::TGMenuTitle[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMenuTitle(void *p) {
      delete ((::TGMenuTitle*)p);
   }
   static void deleteArray_TGMenuTitle(void *p) {
      delete [] ((::TGMenuTitle*)p);
   }
   static void destruct_TGMenuTitle(void *p) {
      typedef ::TGMenuTitle current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMenuTitle(TBuffer &buf, void *obj) {
      ((::TGMenuTitle*)obj)->::TGMenuTitle::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMenuTitle

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGMenuEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMenuEntry.
      TClass *R__cl = ::TGMenuEntry::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryId", &fEntryId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUserData", &fUserData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEx", &fEx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEy", &fEy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEw", &fEw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEh", &fEh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShortcut", &fShortcut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPopup", &fPopup);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGMenuEntry(void *p) {
      return  p ? new(p) ::TGMenuEntry : new ::TGMenuEntry;
   }
   static void *newArray_TGMenuEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGMenuEntry[nElements] : new ::TGMenuEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGMenuEntry(void *p) {
      delete ((::TGMenuEntry*)p);
   }
   static void deleteArray_TGMenuEntry(void *p) {
      delete [] ((::TGMenuEntry*)p);
   }
   static void destruct_TGMenuEntry(void *p) {
      typedef ::TGMenuEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGMenuEntry(TBuffer &buf, void *obj) {
      ((::TGMenuEntry*)obj)->::TGMenuEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGMenuEntry

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGShutter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGShutter.
      TClass *R__cl = ::TGShutter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedItem", &fSelectedItem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClosingItem", &fClosingItem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrash", &fTrash);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeightIncrement", &fHeightIncrement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClosingHeight", &fClosingHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClosingHadScrollbar", &fClosingHadScrollbar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefWidth", &fDefWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefHeight", &fDefHeight);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGShutter(void *p) {
      return  p ? new(p) ::TGShutter : new ::TGShutter;
   }
   static void *newArray_TGShutter(Long_t nElements, void *p) {
      return p ? new(p) ::TGShutter[nElements] : new ::TGShutter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGShutter(void *p) {
      delete ((::TGShutter*)p);
   }
   static void deleteArray_TGShutter(void *p) {
      delete [] ((::TGShutter*)p);
   }
   static void destruct_TGShutter(void *p) {
      typedef ::TGShutter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGShutter(TBuffer &buf, void *obj) {
      ((::TGShutter*)obj)->::TGShutter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGShutter

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

   TGVerticalFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
}

//______________________________________________________________________________
void TGShutterItem::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGShutterItem.
      TClass *R__cl = ::TGShutterItem::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButton", &fButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContainer", &fContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL1", &fL1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL2", &fL2);
      TGVerticalFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGShutterItem(void *p) {
      return  p ? new(p) ::TGShutterItem : new ::TGShutterItem;
   }
   static void *newArray_TGShutterItem(Long_t nElements, void *p) {
      return p ? new(p) ::TGShutterItem[nElements] : new ::TGShutterItem[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGShutterItem(void *p) {
      delete ((::TGShutterItem*)p);
   }
   static void deleteArray_TGShutterItem(void *p) {
      delete [] ((::TGShutterItem*)p);
   }
   static void destruct_TGShutterItem(void *p) {
      typedef ::TGShutterItem current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGShutterItem(TBuffer &buf, void *obj) {
      ((::TGShutterItem*)obj)->::TGShutterItem::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGShutterItem

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

   TGFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHorizontal3DLine(void *p) {
      return  p ? new(p) ::TGHorizontal3DLine : new ::TGHorizontal3DLine;
   }
   static void *newArray_TGHorizontal3DLine(Long_t nElements, void *p) {
      return p ? new(p) ::TGHorizontal3DLine[nElements] : new ::TGHorizontal3DLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHorizontal3DLine(void *p) {
      delete ((::TGHorizontal3DLine*)p);
   }
   static void deleteArray_TGHorizontal3DLine(void *p) {
      delete [] ((::TGHorizontal3DLine*)p);
   }
   static void destruct_TGHorizontal3DLine(void *p) {
      typedef ::TGHorizontal3DLine current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHorizontal3DLine(TBuffer &buf, void *obj) {
      ((::TGHorizontal3DLine*)obj)->::TGHorizontal3DLine::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHorizontal3DLine

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

   TGFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVertical3DLine(void *p) {
      return  p ? new(p) ::TGVertical3DLine : new ::TGVertical3DLine;
   }
   static void *newArray_TGVertical3DLine(Long_t nElements, void *p) {
      return p ? new(p) ::TGVertical3DLine[nElements] : new ::TGVertical3DLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVertical3DLine(void *p) {
      delete ((::TGVertical3DLine*)p);
   }
   static void deleteArray_TGVertical3DLine(void *p) {
      delete [] ((::TGVertical3DLine*)p);
   }
   static void destruct_TGVertical3DLine(void *p) {
      typedef ::TGVertical3DLine current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVertical3DLine(TBuffer &buf, void *obj) {
      ((::TGVertical3DLine*)obj)->::TGVertical3DLine::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVertical3DLine

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGGC::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGGC.
      TClass *R__cl = ::TGGC::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValues", (void*)&fValues);
      R__insp.InspectMember("GCValues_t", (void*)&fValues, "fValues.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContext", &fContext);
      TObject::ShowMembers(R__insp);
      R__insp.GenericShowMembers("TRefCnt", ( ::TRefCnt *) (this ), false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGGC(void *p) {
      return  p ? new(p) ::TGGC : new ::TGGC;
   }
   static void *newArray_TGGC(Long_t nElements, void *p) {
      return p ? new(p) ::TGGC[nElements] : new ::TGGC[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGGC(void *p) {
      delete ((::TGGC*)p);
   }
   static void deleteArray_TGGC(void *p) {
      delete [] ((::TGGC*)p);
   }
   static void destruct_TGGC(void *p) {
      typedef ::TGGC current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGGC(TBuffer &buf, void *obj) {
      ((::TGGC*)obj)->::TGGC::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGGC

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

   TGObject::Streamer(R__b);
}

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

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

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGProgressBar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGProgressBar.
      TClass *R__cl = ::TGProgressBar::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPosPix", &fPosPix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarWidth", &fBarWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillType", &fFillType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarType", &fBarType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFormat", &fFormat);
      R__insp.InspectMember(fFormat, "fFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowPos", &fShowPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPercent", &fPercent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawBar", &fDrawBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarColorGC", &fBarColorGC);
      R__insp.InspectMember(fBarColorGC, "fBarColorGC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      TGFrame::ShowMembers(R__insp);
}

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

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

   TGProgressBar::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHProgressBar(void *p) {
      return  p ? new(p) ::TGHProgressBar : new ::TGHProgressBar;
   }
   static void *newArray_TGHProgressBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGHProgressBar[nElements] : new ::TGHProgressBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHProgressBar(void *p) {
      delete ((::TGHProgressBar*)p);
   }
   static void deleteArray_TGHProgressBar(void *p) {
      delete [] ((::TGHProgressBar*)p);
   }
   static void destruct_TGHProgressBar(void *p) {
      typedef ::TGHProgressBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHProgressBar(TBuffer &buf, void *obj) {
      ((::TGHProgressBar*)obj)->::TGHProgressBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHProgressBar

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

   TGProgressBar::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVProgressBar(void *p) {
      return  p ? new(p) ::TGVProgressBar : new ::TGVProgressBar;
   }
   static void *newArray_TGVProgressBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGVProgressBar[nElements] : new ::TGVProgressBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVProgressBar(void *p) {
      delete ((::TGVProgressBar*)p);
   }
   static void deleteArray_TGVProgressBar(void *p) {
      delete [] ((::TGVProgressBar*)p);
   }
   static void destruct_TGVProgressBar(void *p) {
      typedef ::TGVProgressBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVProgressBar(TBuffer &buf, void *obj) {
      ((::TGVProgressBar*)obj)->::TGVProgressBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVProgressBar

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGNumberFormat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGNumberFormat : new ::TGNumberFormat;
   }
   static void *newArray_TGNumberFormat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGNumberFormat[nElements] : new ::TGNumberFormat[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGNumberFormat(void *p) {
      delete ((::TGNumberFormat*)p);
   }
   static void deleteArray_TGNumberFormat(void *p) {
      delete [] ((::TGNumberFormat*)p);
   }
   static void destruct_TGNumberFormat(void *p) {
      typedef ::TGNumberFormat current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGNumberFormat(TBuffer &buf, void *obj) {
      ((::TGNumberFormat*)obj)->::TGNumberFormat::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGNumberFormat

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

   TGTextEntry::Streamer(R__b);
   TGNumberFormat::Streamer(R__b);
}

//______________________________________________________________________________
void TGNumberEntryField::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGNumberEntryField.
      TClass *R__cl = ::TGNumberEntryField::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeedsVerification", &fNeedsVerification);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumStyle", &fNumStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumAttr", &fNumAttr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumLimits", &fNumLimits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumMin", &fNumMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumMax", &fNumMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStepLog", &fStepLog);
      TGTextEntry::ShowMembers(R__insp);
      TGNumberFormat::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGNumberEntryField(void *p) {
      return  p ? new(p) ::TGNumberEntryField : new ::TGNumberEntryField;
   }
   static void *newArray_TGNumberEntryField(Long_t nElements, void *p) {
      return p ? new(p) ::TGNumberEntryField[nElements] : new ::TGNumberEntryField[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGNumberEntryField(void *p) {
      delete ((::TGNumberEntryField*)p);
   }
   static void deleteArray_TGNumberEntryField(void *p) {
      delete [] ((::TGNumberEntryField*)p);
   }
   static void destruct_TGNumberEntryField(void *p) {
      typedef ::TGNumberEntryField current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGNumberEntryField(TBuffer &buf, void *obj) {
      ((::TGNumberEntryField*)obj)->::TGNumberEntryField::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGNumberEntryField

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

   TGCompositeFrame::Streamer(R__b);
   TGWidget::Streamer(R__b);
   TGNumberFormat::Streamer(R__b);
}

//______________________________________________________________________________
void TGNumberEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGNumberEntry.
      TClass *R__cl = ::TGNumberEntry::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumStyle", &fNumStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumAttr", &fNumAttr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumLimits", &fNumLimits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicUp", &fPicUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicDown", &fPicDown);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNumericEntry", &fNumericEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtonUp", &fButtonUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtonDown", &fButtonDown);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fButtonToNum", &fButtonToNum);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
      TGNumberFormat::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGNumberEntry(void *p) {
      return  p ? new(p) ::TGNumberEntry : new ::TGNumberEntry;
   }
   static void *newArray_TGNumberEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGNumberEntry[nElements] : new ::TGNumberEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGNumberEntry(void *p) {
      delete ((::TGNumberEntry*)p);
   }
   static void deleteArray_TGNumberEntry(void *p) {
      delete [] ((::TGNumberEntry*)p);
   }
   static void destruct_TGNumberEntry(void *p) {
      typedef ::TGNumberEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGNumberEntry(TBuffer &buf, void *obj) {
      ((::TGNumberEntry*)obj)->::TGNumberEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGNumberEntry

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

   TGLayoutManager::Streamer(R__b);
}

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

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

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGPack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGPack.
      TClass *R__cl = ::TGPack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVertical", &fVertical);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSplitters", &fUseSplitters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSplitterLen", &fSplitterLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragOverflow", &fDragOverflow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightSum", &fWeightSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVisible", &fNVisible);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGPack(void *p) {
      return  p ? new(p) ::TGPack : new ::TGPack;
   }
   static void *newArray_TGPack(Long_t nElements, void *p) {
      return p ? new(p) ::TGPack[nElements] : new ::TGPack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGPack(void *p) {
      delete ((::TGPack*)p);
   }
   static void deleteArray_TGPack(void *p) {
      delete [] ((::TGPack*)p);
   }
   static void destruct_TGPack(void *p) {
      typedef ::TGPack current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGPack(TBuffer &buf, void *obj) {
      ((::TGPack*)obj)->::TGPack::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGPack

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

   TGFrameElement::Streamer(R__b);
}

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

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

/********************************************************
* gui/gui/src/G__Gui1.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__Gui1();

extern "C" void G__set_cpp_environmentG__Gui1() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TGObject.h");
  G__add_compiledheader("TGClient.h");
  G__add_compiledheader("TGWindow.h");
  G__add_compiledheader("TGPicture.h");
  G__add_compiledheader("TGDimension.h");
  G__add_compiledheader("TGFrame.h");
  G__add_compiledheader("TGLayout.h");
  G__add_compiledheader("TGString.h");
  G__add_compiledheader("TGWidget.h");
  G__add_compiledheader("TGIcon.h");
  G__add_compiledheader("TGLabel.h");
  G__add_compiledheader("TGButton.h");
  G__add_compiledheader("TGTextBuffer.h");
  G__add_compiledheader("TGTextEntry.h");
  G__add_compiledheader("TGMsgBox.h");
  G__add_compiledheader("TGMenu.h");
  G__add_compiledheader("TGGC.h");
  G__add_compiledheader("TGShutter.h");
  G__add_compiledheader("TG3DLine.h");
  G__add_compiledheader("TGProgressBar.h");
  G__add_compiledheader("TGButtonGroup.h");
  G__add_compiledheader("TGNumberEntry.h");
  G__add_compiledheader("TGTableLayout.h");
  G__add_compiledheader("WidgetMessageTypes.h");
  G__add_compiledheader("TGIdleHandler.h");
  G__add_compiledheader("TGInputDialog.h");
  G__add_compiledheader("TGPack.h");
  G__cpp_reset_tagtableG__Gui1();
}
#include <new>
extern "C" int G__cpp_dllrevG__Gui1() { return(30051515); }

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

/* TGClient */
static int G__G__Gui1_115_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGClient* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGClient((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGClient((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 TGClient[n];
       } else {
         p = new((void*) gvp) TGClient[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGClient;
       } else {
         p = new((void*) gvp) TGClient;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGClient));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__G__Gui1_115_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 107, (long) ((const TGClient*) G__getstructoffset())->GetFontByName((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 107, (long) ((const TGClient*) G__getstructoffset())->GetFontByName((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_115_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGClient*) G__getstructoffset())->GetColorByName((const char*) G__int(libp->para[0]), *(Pixel_t*) G__ULongref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_115_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGClient*) G__getstructoffset())->GetHilite((Pixel_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_115_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGClient*) G__getstructoffset())->GetShadow((Pixel_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Gui1_115_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGClient*) G__getstructoffset())->NeedRedraw((TGWindow*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGClient*) G__getstructoffset())->NeedRedraw((TGWindow*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__Gui1_115_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGClient*) G__getstructoffset())->ProcessLine(*((TString*) 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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Gui1_115_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGClient*) G__getstructoffset())->HandleMaskEvent((Event_t*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui1_115_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGClient*) G__getstructoffset())->ProcessedEvent((Event_t*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Gui1_115_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGClient*) G__getstructoffset())->GetGC((GCValues_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGClient*) G__getstructoffset())->GetGC((GCValues_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGWindow */
static int G__G__Gui1_132_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGWindow* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]), (SetWindowAttributes_t*) G__int(libp->para[9])
, (UInt_t) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]), (SetWindowAttributes_t*) G__int(libp->para[9])
, (UInt_t) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]), (SetWindowAttributes_t*) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]), (SetWindowAttributes_t*) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (void*) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGWindow((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGWindow((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGWindow((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGWindow[n];
       } else {
         p = new((void*) gvp) TGWindow[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGWindow;
       } else {
         p = new((void*) gvp) TGWindow;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_132_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGWindow* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGWindow(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWindow((TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGWindow((TGClient*) G__int(libp->para[0]), (Window_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__Gui1LN_TGWindow));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Gui1_132_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWindow*) G__getstructoffset())->Move((Int_t) 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__Gui1_132_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWindow*) G__getstructoffset())->Resize((UInt_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__Gui1_132_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWindow*) G__getstructoffset())->MoveResize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGPicturePool */
static int G__G__Gui1_134_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPicturePool* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGPicturePool((TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGPicturePool((TGClient*) 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__Gui1LN_TGPicturePool));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TGPicturePool G__TTGPicturePool;
static int G__G__Gui1_134_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGPicturePool*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPicturePool*) (soff+(sizeof(TGPicturePool)*i)))->~G__TTGPicturePool();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPicturePool*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPicturePool*) (soff))->~G__TTGPicturePool();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

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

static int G__G__Gui1_135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPicture::HashName((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_135_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGPicture*) G__getstructoffset())->Draw((Handle_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic copy constructor
static int G__G__Gui1_135_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGPicture* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGPicture(*(TGPicture*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__G__Gui1_136_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGGCPool*) G__getstructoffset())->GetGC((GCValues_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGGCPool*) G__getstructoffset())->GetGC((GCValues_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGGC */
static int G__G__Gui1_137_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGGC* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGC((GCValues_t*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGGC((GCValues_t*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGGC[n];
       } else {
         p = new((void*) gvp) TGGC[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGGC;
       } else {
         p = new((void*) gvp) TGGC;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGGC));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Gui1_137_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGC*) G__getstructoffset())->SetDashList((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__Gui1_137_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGC*) G__getstructoffset())->SetArcMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Gui1_137_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetLineStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGGC*) G__getstructoffset())->GetTile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGGC*) G__getstructoffset())->GetStipple());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetTileStipXOrigin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetTileStipYOrigin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetSubwindowMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGGC*) G__getstructoffset())->GetFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGGC*) G__getstructoffset())->GetGraphicsExposures());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetClipXOrigin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetClipYOrigin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGGC*) G__getstructoffset())->GetClipMask());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetCapStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetJoinStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetFillStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetFillRule());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetDashOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetDashLen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGGC*) G__getstructoffset())->GetDashes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGC*) G__getstructoffset())->GetArcMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGGC::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGC::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGGC::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGGC::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGC*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGC::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGGC::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGC::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_137_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGGC::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGGC G__TTGGC;
static int G__G__Gui1_137_0_73(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[] (TGGC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGGC*) (soff+(sizeof(TGGC)*i)))->~G__TTGGC();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGGC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGGC*) (soff))->~G__TTGGC();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGUnknownWindowHandler */
static int G__G__Gui1_141_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGUnknownWindowHandler*) G__getstructoffset())->HandleEvent((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGUnknownWindowHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGUnknownWindowHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGUnknownWindowHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGUnknownWindowHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGUnknownWindowHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGUnknownWindowHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGUnknownWindowHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGUnknownWindowHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_141_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGUnknownWindowHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGUnknownWindowHandler G__TTGUnknownWindowHandler;
static int G__G__Gui1_141_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGUnknownWindowHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGUnknownWindowHandler*) (soff+(sizeof(TGUnknownWindowHandler)*i)))->~G__TTGUnknownWindowHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGUnknownWindowHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGUnknownWindowHandler*) (soff))->~G__TTGUnknownWindowHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_141_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGUnknownWindowHandler* dest = (TGUnknownWindowHandler*) G__getstructoffset();
   *dest = *(TGUnknownWindowHandler*) libp->para[0].ref;
   const TGUnknownWindowHandler& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGIdleHandler */
static int G__G__Gui1_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGIdleHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGIdleHandler((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGIdleHandler((TGWindow*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGIdleHandler*) G__getstructoffset())->HandleEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGIdleHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIdleHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGIdleHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGIdleHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIdleHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIdleHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGIdleHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIdleHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_142_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGIdleHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_142_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGIdleHandler* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGIdleHandler(*(TGIdleHandler*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGIdleHandler G__TTGIdleHandler;
static int G__G__Gui1_142_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[] (TGIdleHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGIdleHandler*) (soff+(sizeof(TGIdleHandler)*i)))->~G__TTGIdleHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGIdleHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGIdleHandler*) (soff))->~G__TTGIdleHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_142_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGIdleHandler* dest = (TGIdleHandler*) G__getstructoffset();
   *dest = *(TGIdleHandler*) libp->para[0].ref;
   const TGIdleHandler& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSelectedPicture */
static int G__G__Gui1_160_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSelectedPicture* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGSelectedPicture((TGClient*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGSelectedPicture((TGClient*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSelectedPicture::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSelectedPicture::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSelectedPicture::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSelectedPicture::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSelectedPicture*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSelectedPicture::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSelectedPicture::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSelectedPicture::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_160_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSelectedPicture::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSelectedPicture G__TTGSelectedPicture;
static int G__G__Gui1_160_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGSelectedPicture*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSelectedPicture*) (soff+(sizeof(TGSelectedPicture)*i)))->~G__TTGSelectedPicture();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSelectedPicture*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSelectedPicture*) (soff))->~G__TTGSelectedPicture();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDimension */
static int G__G__Gui1_161_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDimension* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDimension[n];
     } else {
       p = new((void*) gvp) TGDimension[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDimension;
     } else {
       p = new((void*) gvp) TGDimension;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGDimension));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDimension* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGDimension((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGDimension((UInt_t) G__int(libp->para[0]), (UInt_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__Gui1LN_TGDimension));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDimension* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGDimension(*(TGDimension*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGDimension(*(TGDimension*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGDimension));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGDimension*) G__getstructoffset())->operator==(*(TGDimension*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGDimension*) G__getstructoffset())->operator-(*(TGDimension*) libp->para[0].ref);
         pobj = new TGDimension(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__Gui1_161_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGDimension*) G__getstructoffset())->operator+(*(TGDimension*) libp->para[0].ref);
         pobj = new TGDimension(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__Gui1_161_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDimension::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDimension::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDimension::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDimension::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGDimension*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDimension*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDimension*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDimension*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDimension::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDimension::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDimension::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_161_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDimension::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDimension G__TTGDimension;
static int G__G__Gui1_161_0_19(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[] (TGDimension*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDimension*) (soff+(sizeof(TGDimension)*i)))->~G__TTGDimension();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDimension*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDimension*) (soff))->~G__TTGDimension();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_161_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDimension* dest = (TGDimension*) G__getstructoffset();
   *dest = *(TGDimension*) libp->para[0].ref;
   const TGDimension& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGPosition */
static int G__G__Gui1_162_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPosition[n];
     } else {
       p = new((void*) gvp) TGPosition[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPosition;
     } else {
       p = new((void*) gvp) TGPosition;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGPosition((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGPosition((Int_t) G__int(libp->para[0]), (Int_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__Gui1LN_TGPosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGPosition(*(TGPosition*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGPosition(*(TGPosition*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGPosition*) G__getstructoffset())->operator==(*(TGPosition*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPosition* pobj;
         const TGPosition xobj = ((const TGPosition*) G__getstructoffset())->operator-(*(TGPosition*) libp->para[0].ref);
         pobj = new TGPosition(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__Gui1_162_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPosition* pobj;
         const TGPosition xobj = ((const TGPosition*) G__getstructoffset())->operator+(*(TGPosition*) libp->para[0].ref);
         pobj = new TGPosition(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__Gui1_162_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGPosition::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPosition::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGPosition::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGPosition::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPosition*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPosition*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPosition*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPosition*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPosition::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPosition::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPosition::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_162_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPosition::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGPosition G__TTGPosition;
static int G__G__Gui1_162_0_19(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[] (TGPosition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPosition*) (soff+(sizeof(TGPosition)*i)))->~G__TTGPosition();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPosition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPosition*) (soff))->~G__TTGPosition();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_162_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPosition* dest = (TGPosition*) G__getstructoffset();
   *dest = *(TGPosition*) libp->para[0].ref;
   const TGPosition& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLongPosition */
static int G__G__Gui1_163_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLongPosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLongPosition[n];
     } else {
       p = new((void*) gvp) TGLongPosition[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLongPosition;
     } else {
       p = new((void*) gvp) TGLongPosition;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLongPosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLongPosition((Long_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGLongPosition((Long_t) G__int(libp->para[0]), (Long_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__Gui1LN_TGLongPosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLongPosition* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLongPosition(*(TGLongPosition*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLongPosition(*(TGLongPosition*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLongPosition*) G__getstructoffset())->operator==(*(TGLongPosition*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGLongPosition*) G__getstructoffset())->operator-(*(TGLongPosition*) libp->para[0].ref);
         pobj = new TGLongPosition(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__Gui1_163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGLongPosition*) G__getstructoffset())->operator+(*(TGLongPosition*) libp->para[0].ref);
         pobj = new TGLongPosition(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__Gui1_163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLongPosition::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLongPosition::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLongPosition::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLongPosition::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLongPosition*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLongPosition*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLongPosition*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLongPosition*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLongPosition::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLongPosition::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLongPosition::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLongPosition::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLongPosition G__TTGLongPosition;
static int G__G__Gui1_163_0_19(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[] (TGLongPosition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLongPosition*) (soff+(sizeof(TGLongPosition)*i)))->~G__TTGLongPosition();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLongPosition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLongPosition*) (soff))->~G__TTGLongPosition();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLongPosition* dest = (TGLongPosition*) G__getstructoffset();
   *dest = *(TGLongPosition*) libp->para[0].ref;
   const TGLongPosition& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGInsets */
static int G__G__Gui1_164_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGInsets* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGInsets[n];
     } else {
       p = new((void*) gvp) TGInsets[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGInsets;
     } else {
       p = new((void*) gvp) TGInsets;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGInsets));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGInsets* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGInsets(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGInsets(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGInsets));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGInsets* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGInsets(*(TGInsets*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGInsets(*(TGInsets*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGInsets));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGInsets*) G__getstructoffset())->operator==(*(TGInsets*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGInsets::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGInsets::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGInsets::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGInsets::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGInsets*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGInsets*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGInsets*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGInsets*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGInsets::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGInsets::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGInsets::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_164_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGInsets::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGInsets G__TTGInsets;
static int G__G__Gui1_164_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[] (TGInsets*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGInsets*) (soff+(sizeof(TGInsets)*i)))->~G__TTGInsets();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGInsets*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGInsets*) (soff))->~G__TTGInsets();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_164_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGInsets* dest = (TGInsets*) G__getstructoffset();
   *dest = *(TGInsets*) libp->para[0].ref;
   const TGInsets& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRectangle */
static int G__G__Gui1_165_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRectangle* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRectangle[n];
     } else {
       p = new((void*) gvp) TGRectangle[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRectangle;
     } else {
       p = new((void*) gvp) TGRectangle;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRectangle* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRectangle(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGRectangle(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRectangle* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRectangle(*(TGPosition*) libp->para[0].ref, *(TGDimension*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGRectangle(*(TGPosition*) libp->para[0].ref, *(TGDimension*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRectangle* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRectangle(*(TGRectangle*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGRectangle(*(TGRectangle*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRectangle*) G__getstructoffset())->Contains((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRectangle*) G__getstructoffset())->Contains(*(TGPosition*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRectangle*) G__getstructoffset())->Intersects(*(TGRectangle*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGRectangle*) G__getstructoffset())->Area());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGRectangle*) G__getstructoffset())->Size();
         pobj = new TGDimension(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__Gui1_165_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPosition* pobj;
         const TGPosition xobj = ((const TGRectangle*) G__getstructoffset())->LeftTop();
         pobj = new TGPosition(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__Gui1_165_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPosition* pobj;
         const TGPosition xobj = ((const TGRectangle*) G__getstructoffset())->RightBottom();
         pobj = new TGPosition(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__Gui1_165_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRectangle*) G__getstructoffset())->Merge(*(TGRectangle*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRectangle*) G__getstructoffset())->Empty();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRectangle*) G__getstructoffset())->IsEmpty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRectangle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRectangle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRectangle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRectangle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGRectangle*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRectangle*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRectangle*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRectangle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRectangle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRectangle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRectangle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_165_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRectangle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRectangle G__TTGRectangle;
static int G__G__Gui1_165_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGRectangle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRectangle*) (soff+(sizeof(TGRectangle)*i)))->~G__TTGRectangle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRectangle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRectangle*) (soff))->~G__TTGRectangle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_165_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRectangle* dest = (TGRectangle*) G__getstructoffset();
   *dest = *(TGRectangle*) libp->para[0].ref;
   const TGRectangle& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFrame */
static int G__G__Gui1_177_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGFrame::GetDefaultFrameBackground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGFrame::GetDefaultSelectedBackground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGFrame::GetWhitePixel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGFrame::GetBlackPixel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGFrame::GetBlackGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGFrame::GetWhiteGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGFrame::GetHilightGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGFrame::GetShadowGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGFrame::GetBckgndGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFrame[n];
       } else {
         p = new((void*) gvp) TGFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFrame;
       } else {
         p = new((void*) gvp) TGFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFrame(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrame((TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFrame((TGClient*) G__int(libp->para[0]), (Window_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__Gui1LN_TGFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->DeleteWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->ReallyDelete();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetEventMask());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->AddInput((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->RemoveInput((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleConfigureNotify((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleButton((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDoubleClick((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleCrossing((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleMotion((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleKey((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleFocusChange((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleClientMessage((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleSelection((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleSelectionRequest((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleSelectionClear((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleColormapChange((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDragEnter((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDragLeave((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDragMotion((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDragDrop((TGFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGLayoutHints*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->ProcessedConfigure((Event_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->ProcessedEvent((Event_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SendMessage((TGWindow*) 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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->ProcessMessage((Long_t) 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__Gui1_177_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGFrame*) G__getstructoffset())->GetDefaultSize();
         pobj = new TGDimension(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__Gui1_177_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGFrame*) G__getstructoffset())->Resize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGFrame*) G__getstructoffset())->Resize((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGFrame*) G__getstructoffset())->Resize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->Resize(*((TGDimension*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGFrame*) G__getstructoffset())->MoveResize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGFrame*) G__getstructoffset())->MoveResize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGFrame*) G__getstructoffset())->MoveResize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetDefaultWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetDefaultHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGFrame*) G__getstructoffset())->GetBackground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->ChangeBackground((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGFrame*) G__getstructoffset())->GetForeground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetForegroundColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetOptions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->ChangeOptions((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->Layout();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->DrawBorder();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->DrawCopy((Handle_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__Gui1_177_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->Activate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFrame*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFrame*) G__getstructoffset())->IsComposite());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGFrame*) G__getstructoffset())->SetLayoutBroken((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGFrame*) G__getstructoffset())->SetLayoutBroken();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFrame*) G__getstructoffset())->IsLayoutBroken());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGFrame*) G__getstructoffset())->SetCleanup((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGFrame*) G__getstructoffset())->SetCleanup();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetDragType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetDropType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFrame*) G__getstructoffset())->GetDragType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFrame*) G__getstructoffset())->GetDropType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetMinWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetMinHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetMaxWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGFrame*) G__getstructoffset())->GetMaxHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGFrame*) G__getstructoffset())->GetSize();
         pobj = new TGDimension(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__Gui1_177_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFrame*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFrame*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFrame*) G__getstructoffset())->GetBorderWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGFrame*) G__getstructoffset())->GetFrameElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetFrameElement((TGFrameElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFrame*) G__getstructoffset())->Contains((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGFrame*) G__getstructoffset())->GetFrameFromPoint((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetWidth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetHeight((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetMinWidth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetMinHeight((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetMaxWidth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetMaxHeight((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetSize(*(TGDimension*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SaveUserColor(*(ostream*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetDNDSource((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->SetDNDTarget((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFrame*) G__getstructoffset())->IsDNDSource());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFrame*) G__getstructoffset())->IsDNDTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGFrame*) G__getstructoffset())->GetDNDData((Atom_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDNDDrop((TDNDData*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TGFrame*) G__getstructoffset())->HandleDNDPosition((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Atom_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TGFrame*) G__getstructoffset())->HandleDNDEnter((Atom_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDNDLeave());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFrame*) G__getstructoffset())->HandleDNDFinished());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_177_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFrame G__TTGFrame;
static int G__G__Gui1_177_0_135(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[] (TGFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFrame*) (soff+(sizeof(TGFrame)*i)))->~G__TTGFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFrame*) (soff))->~G__TTGFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGCompositeFrame */
static int G__G__Gui1_178_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCompositeFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGCompositeFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGCompositeFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGCompositeFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGCompositeFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGCompositeFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGCompositeFrame[n];
       } else {
         p = new((void*) gvp) TGCompositeFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGCompositeFrame;
       } else {
         p = new((void*) gvp) TGCompositeFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCompositeFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGCompositeFrame(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCompositeFrame((TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGCompositeFrame((TGClient*) G__int(libp->para[0]), (Window_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__Gui1LN_TGCompositeFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGCompositeFrame*) G__getstructoffset())->GetList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGCompositeFrame*) G__getstructoffset())->TranslateCoordinates((TGFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGCompositeFrame*) G__getstructoffset())->GetLayoutManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->SetLayoutManager((TGLayoutManager*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGCompositeFrame*) G__getstructoffset())->FindFrameElement((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGCompositeFrame*) G__getstructoffset())->AddFrame((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGCompositeFrame*) G__getstructoffset())->AddFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->RemoveAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->RemoveFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->ShowFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->HideFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGCompositeFrame*) G__getstructoffset())->GetState((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGCompositeFrame*) G__getstructoffset())->IsVisible((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGCompositeFrame*) G__getstructoffset())->IsVisible((TGFrameElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGCompositeFrame*) G__getstructoffset())->IsArranged((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGCompositeFrame*) G__getstructoffset())->IsArranged((TGFrameElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGCompositeFrame*) G__getstructoffset())->SetEditable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGCompositeFrame*) G__getstructoffset())->SetEditable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->Cleanup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->ChangeSubframesBackground((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGCompositeFrame*) G__getstructoffset())->SavePrimitiveSubframes(*(ostream*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGCompositeFrame*) G__getstructoffset())->SavePrimitiveSubframes(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGCompositeFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCompositeFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGCompositeFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGCompositeFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCompositeFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCompositeFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCompositeFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCompositeFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_178_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCompositeFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGCompositeFrame G__TTGCompositeFrame;
static int G__G__Gui1_178_0_66(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[] (TGCompositeFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGCompositeFrame*) (soff+(sizeof(TGCompositeFrame)*i)))->~G__TTGCompositeFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGCompositeFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGCompositeFrame*) (soff))->~G__TTGCompositeFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLayoutHints */
static int G__G__Gui1_179_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLayoutHints* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLayoutHints(
(ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLayoutHints(
(ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLayoutHints(
(ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLayoutHints(
(ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLayoutHints(
(ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLayoutHints(
(ULong_t) G__int(libp->para[0]), (Int_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 TGLayoutHints((ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLayoutHints((ULong_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLayoutHints((ULong_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLayoutHints((ULong_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLayoutHints[n];
       } else {
         p = new((void*) gvp) TGLayoutHints[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLayoutHints;
       } else {
         p = new((void*) gvp) TGLayoutHints;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLayoutHints* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLayoutHints(*(TGLayoutHints*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLayoutHints(*(TGLayoutHints*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGLayoutHints*) G__getstructoffset())->GetLayoutHints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLayoutHints*) G__getstructoffset())->GetPadTop());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLayoutHints*) G__getstructoffset())->GetPadBottom());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLayoutHints*) G__getstructoffset())->GetPadLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLayoutHints*) G__getstructoffset())->GetPadRight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutHints*) G__getstructoffset())->SetLayoutHints((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutHints*) G__getstructoffset())->SetPadTop((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutHints*) G__getstructoffset())->SetPadBottom((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutHints*) G__getstructoffset())->SetPadLeft((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutHints*) G__getstructoffset())->SetPadRight((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLayoutHints::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLayoutHints::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLayoutHints::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLayoutHints::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutHints*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLayoutHints::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLayoutHints::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLayoutHints::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_179_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLayoutHints::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLayoutHints G__TTGLayoutHints;
static int G__G__Gui1_179_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[] (TGLayoutHints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLayoutHints*) (soff+(sizeof(TGLayoutHints)*i)))->~G__TTGLayoutHints();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLayoutHints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLayoutHints*) (soff))->~G__TTGLayoutHints();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFrameElement */
static int G__G__Gui1_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFrameElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrameElement[n];
     } else {
       p = new((void*) gvp) TGFrameElement[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrameElement;
     } else {
       p = new((void*) gvp) TGFrameElement;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFrameElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGFrameElement((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGFrameElement((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFrameElement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrameElement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFrameElement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFrameElement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrameElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrameElement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFrameElement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrameElement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_180_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFrameElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFrameElement G__TTGFrameElement;
static int G__G__Gui1_180_0_19(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[] (TGFrameElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFrameElement*) (soff+(sizeof(TGFrameElement)*i)))->~G__TTGFrameElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFrameElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFrameElement*) (soff))->~G__TTGFrameElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLayoutManager */
static int G__G__Gui1_181_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutManager*) G__getstructoffset())->Layout();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGLayoutManager*) G__getstructoffset())->GetDefaultSize();
         pobj = new TGDimension(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__Gui1_181_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutManager*) G__getstructoffset())->SetDefaultWidth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutManager*) G__getstructoffset())->SetDefaultHeight((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLayoutManager*) G__getstructoffset())->IsModified());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLayoutManager*) G__getstructoffset())->SetModified((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLayoutManager*) G__getstructoffset())->SetModified();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLayoutManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLayoutManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLayoutManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLayoutManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLayoutManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLayoutManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLayoutManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLayoutManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_181_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLayoutManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLayoutManager G__TTGLayoutManager;
static int G__G__Gui1_181_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[] (TGLayoutManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLayoutManager*) (soff+(sizeof(TGLayoutManager)*i)))->~G__TTGLayoutManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLayoutManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLayoutManager*) (soff))->~G__TTGLayoutManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_181_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLayoutManager* dest = (TGLayoutManager*) G__getstructoffset();
   *dest = *(TGLayoutManager*) libp->para[0].ref;
   const TGLayoutManager& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVerticalLayout */
static int G__G__Gui1_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVerticalLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGVerticalLayout((TGCompositeFrame*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGVerticalLayout((TGCompositeFrame*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVerticalLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVerticalLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVerticalLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVerticalLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVerticalLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVerticalLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVerticalLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVerticalLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_182_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVerticalLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVerticalLayout G__TTGVerticalLayout;
static int G__G__Gui1_182_0_19(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[] (TGVerticalLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVerticalLayout*) (soff+(sizeof(TGVerticalLayout)*i)))->~G__TTGVerticalLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVerticalLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVerticalLayout*) (soff))->~G__TTGVerticalLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHorizontalLayout */
static int G__G__Gui1_183_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHorizontalLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGHorizontalLayout((TGCompositeFrame*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGHorizontalLayout((TGCompositeFrame*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHorizontalLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontalLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHorizontalLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHorizontalLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHorizontalLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontalLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHorizontalLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontalLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_183_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHorizontalLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_183_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGHorizontalLayout* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGHorizontalLayout(*(TGHorizontalLayout*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHorizontalLayout G__TTGHorizontalLayout;
static int G__G__Gui1_183_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[] (TGHorizontalLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHorizontalLayout*) (soff+(sizeof(TGHorizontalLayout)*i)))->~G__TTGHorizontalLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHorizontalLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHorizontalLayout*) (soff))->~G__TTGHorizontalLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRowLayout */
static int G__G__Gui1_184_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRowLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRowLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGRowLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRowLayout((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGRowLayout((TGCompositeFrame*) 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__Gui1LN_TGRowLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRowLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRowLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRowLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRowLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRowLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRowLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRowLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRowLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_184_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRowLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_184_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGRowLayout* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGRowLayout(*(TGRowLayout*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRowLayout G__TTGRowLayout;
static int G__G__Gui1_184_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[] (TGRowLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRowLayout*) (soff+(sizeof(TGRowLayout)*i)))->~G__TTGRowLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRowLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRowLayout*) (soff))->~G__TTGRowLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGColumnLayout */
static int G__G__Gui1_185_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGColumnLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColumnLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGColumnLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGColumnLayout((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGColumnLayout((TGCompositeFrame*) 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__Gui1LN_TGColumnLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGColumnLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColumnLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGColumnLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGColumnLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGColumnLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColumnLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColumnLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGColumnLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_185_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGColumnLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_185_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGColumnLayout* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGColumnLayout(*(TGColumnLayout*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGColumnLayout G__TTGColumnLayout;
static int G__G__Gui1_185_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[] (TGColumnLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGColumnLayout*) (soff+(sizeof(TGColumnLayout)*i)))->~G__TTGColumnLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGColumnLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGColumnLayout*) (soff))->~G__TTGColumnLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMatrixLayout */
static int G__G__Gui1_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMatrixLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMatrixLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMatrixLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMatrixLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGMatrixLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMatrixLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMatrixLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMatrixLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMatrixLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMatrixLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMatrixLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMatrixLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMatrixLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMatrixLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMatrixLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_186_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMatrixLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMatrixLayout G__TTGMatrixLayout;
static int G__G__Gui1_186_0_19(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[] (TGMatrixLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMatrixLayout*) (soff+(sizeof(TGMatrixLayout)*i)))->~G__TTGMatrixLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMatrixLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMatrixLayout*) (soff))->~G__TTGMatrixLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTileLayout */
static int G__G__Gui1_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTileLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTileLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTileLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTileLayout((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTileLayout((TGCompositeFrame*) 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__Gui1LN_TGTileLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTileLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTileLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTileLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTileLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTileLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTileLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTileLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTileLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_187_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTileLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTileLayout G__TTGTileLayout;
static int G__G__Gui1_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[] (TGTileLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTileLayout*) (soff+(sizeof(TGTileLayout)*i)))->~G__TTGTileLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTileLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTileLayout*) (soff))->~G__TTGTileLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListLayout */
static int G__G__Gui1_188_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGListLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListLayout((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGListLayout((TGCompositeFrame*) 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__Gui1LN_TGListLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_188_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListLayout G__TTGListLayout;
static int G__G__Gui1_188_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGListLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListLayout*) (soff+(sizeof(TGListLayout)*i)))->~G__TTGListLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListLayout*) (soff))->~G__TTGListLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListDetailsLayout */
static int G__G__Gui1_189_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListDetailsLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListDetailsLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGListDetailsLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListDetailsLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGListDetailsLayout((TGCompositeFrame*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListDetailsLayout((TGCompositeFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGListDetailsLayout((TGCompositeFrame*) 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__Gui1LN_TGListDetailsLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListDetailsLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListDetailsLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListDetailsLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListDetailsLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListDetailsLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListDetailsLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListDetailsLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListDetailsLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_189_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListDetailsLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListDetailsLayout G__TTGListDetailsLayout;
static int G__G__Gui1_189_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[] (TGListDetailsLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListDetailsLayout*) (soff+(sizeof(TGListDetailsLayout)*i)))->~G__TTGListDetailsLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListDetailsLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListDetailsLayout*) (soff))->~G__TTGListDetailsLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGString */
static int G__G__Gui1_190_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGString* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGString[n];
     } else {
       p = new((void*) gvp) TGString[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGString;
     } else {
       p = new((void*) gvp) TGString;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGString((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGString((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__Gui1LN_TGString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGString((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGString((Int_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__Gui1LN_TGString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGString((TGString*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGString((TGString*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGString*) G__getstructoffset())->GetLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGString*) G__getstructoffset())->GetString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGString*) G__getstructoffset())->SetString((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGString*) G__getstructoffset())->Draw((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGString*) G__getstructoffset())->DrawWrapped((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGString*) G__getstructoffset())->GetLines((FontStruct_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGString::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGString::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGString::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGString::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGString*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGString::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGString::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGString::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_190_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGString::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_190_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGString* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGString(*(TGString*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGString));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGString G__TTGString;
static int G__G__Gui1_190_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[] (TGString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGString*) (soff+(sizeof(TGString)*i)))->~G__TTGString();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGString*) (soff))->~G__TTGString();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_190_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGString* dest = (TGString*) G__getstructoffset();
   *dest = *(TGString*) libp->para[0].ref;
   const TGString& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHotString */
static int G__G__Gui1_191_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHotString* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGHotString((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGHotString((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__Gui1LN_TGHotString));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGHotString*) G__getstructoffset())->GetHotChar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGHotString*) G__getstructoffset())->GetHotPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHotString::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHotString::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHotString::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHotString::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHotString*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHotString::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHotString::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHotString::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_191_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHotString::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_191_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGHotString* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGHotString(*(TGHotString*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHotString));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHotString G__TTGHotString;
static int G__G__Gui1_191_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[] (TGHotString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHotString*) (soff+(sizeof(TGHotString)*i)))->~G__TTGHotString();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHotString*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHotString*) (soff))->~G__TTGHotString();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_191_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHotString* dest = (TGHotString*) G__getstructoffset();
   *dest = *(TGHotString*) libp->para[0].ref;
   const TGHotString& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextButton */
static int G__G__Gui1_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGTextButton::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) 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 TGTextButton((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextButton((TGWindow*) G__int(libp->para[0]), (TGHotString*) 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__Gui1LN_TGTextButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) 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 TGTextButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextButton((TGWindow*) 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 TGTextButton((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextButton((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextButton[n];
       } else {
         p = new((void*) gvp) TGTextButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextButton;
       } else {
         p = new((void*) gvp) TGTextButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextButton*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TGTextButton*) 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__Gui1_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetTextJustify((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextButton*) G__getstructoffset())->GetTextJustify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetText((TGHotString*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetText(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextButton*) G__getstructoffset())->SetFont((FontStruct_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextButton*) G__getstructoffset())->SetFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextButton*) G__getstructoffset())->SetFont((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextButton*) G__getstructoffset())->SetFont((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextButton*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextButton*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextButton*) G__getstructoffset())->HasOwnFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetWrapLength((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextButton*) G__getstructoffset())->GetWrapLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGTextButton*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGTextButton*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGTextButton*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextButton*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextButton*) G__getstructoffset())->SetMargins();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetLeftMargin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetRightMargin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetTopMargin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->SetBottomMargin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextButton*) G__getstructoffset())->GetLeftMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextButton*) G__getstructoffset())->GetRightMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextButton*) G__getstructoffset())->GetTopMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextButton*) G__getstructoffset())->GetBottomMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->ChangeText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTextButton*) G__getstructoffset())->GetFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_202_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextButton G__TTGTextButton;
static int G__G__Gui1_202_0_51(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[] (TGTextButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextButton*) (soff+(sizeof(TGTextButton)*i)))->~G__TTGTextButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextButton*) (soff))->~G__TTGTextButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVerticalFrame */
static int G__G__Gui1_211_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVerticalFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVerticalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGVerticalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVerticalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGVerticalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVerticalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGVerticalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVerticalFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVerticalFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVerticalFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVerticalFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVerticalFrame[n];
       } else {
         p = new((void*) gvp) TGVerticalFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVerticalFrame;
       } else {
         p = new((void*) gvp) TGVerticalFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVerticalFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVerticalFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVerticalFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVerticalFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVerticalFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVerticalFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVerticalFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVerticalFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_211_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVerticalFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVerticalFrame G__TTGVerticalFrame;
static int G__G__Gui1_211_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGVerticalFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVerticalFrame*) (soff+(sizeof(TGVerticalFrame)*i)))->~G__TTGVerticalFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVerticalFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVerticalFrame*) (soff))->~G__TTGVerticalFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHorizontalFrame */
static int G__G__Gui1_212_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHorizontalFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGHorizontalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGHorizontalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGHorizontalFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontalFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHorizontalFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontalFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHorizontalFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHorizontalFrame[n];
       } else {
         p = new((void*) gvp) TGHorizontalFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHorizontalFrame;
       } else {
         p = new((void*) gvp) TGHorizontalFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHorizontalFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontalFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHorizontalFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHorizontalFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHorizontalFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontalFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHorizontalFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontalFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_212_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHorizontalFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHorizontalFrame G__TTGHorizontalFrame;
static int G__G__Gui1_212_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGHorizontalFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHorizontalFrame*) (soff+(sizeof(TGHorizontalFrame)*i)))->~G__TTGHorizontalFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHorizontalFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHorizontalFrame*) (soff))->~G__TTGHorizontalFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMainFrame */
static int G__G__Gui1_213_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMainFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMainFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGMainFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMainFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMainFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMainFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGMainFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMainFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGMainFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMainFrame[n];
       } else {
         p = new((void*) gvp) TGMainFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMainFrame;
       } else {
         p = new((void*) gvp) TGMainFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGMainFrame*) G__getstructoffset())->SaveFrameAsCodeOrImage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SendCloseMessage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->CloseWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->DontCallClose();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetIconName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGMainFrame*) G__getstructoffset())->SetIconPixmap((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetIconPixmap((char**) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetClassHints((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__Gui1_213_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetMWMHints((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetWMPosition((Int_t) 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__Gui1_213_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetWMSize((UInt_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__Gui1_213_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetWMSizeHints((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->SetWMState((EInitialState) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGMainFrame*) G__getstructoffset())->BindKey((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGMainFrame*) G__getstructoffset())->RemoveBind((TGWindow*) 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__Gui1_213_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMainFrame*) G__getstructoffset())->GetBindList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGMainFrame*) G__getstructoffset())->GetWindowName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGMainFrame*) G__getstructoffset())->GetIconPixmap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGMainFrame*) G__getstructoffset())->GetClassHints(libp->para[0].ref ? *(const char**) libp->para[0].ref : *(const char**) (void*) (&G__Mlong(libp->para[0])), libp->para[1].ref ? *(const char**) libp->para[1].ref : *(const char**) (void*) (&G__Mlong(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGMainFrame*) G__getstructoffset())->GetMWMHints(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGMainFrame*) G__getstructoffset())->GetWMPosition(*(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__Gui1_213_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGMainFrame*) G__getstructoffset())->GetWMSize(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGMainFrame*) G__getstructoffset())->GetWMSizeHints(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2]), *(UInt_t*) G__UIntref(&libp->para[3])
, *(UInt_t*) G__UIntref(&libp->para[4]), *(UInt_t*) G__UIntref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMainFrame*) G__getstructoffset())->GetWMState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGMainFrame*) G__getstructoffset())->SaveSource((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGMainFrame*) G__getstructoffset())->SaveSource((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGMainFrame*) G__getstructoffset())->SaveSource();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMainFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMainFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMainFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMainFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMainFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMainFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMainFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMainFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_213_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMainFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMainFrame G__TTGMainFrame;
static int G__G__Gui1_213_0_53(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[] (TGMainFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMainFrame*) (soff+(sizeof(TGMainFrame)*i)))->~G__TTGMainFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMainFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMainFrame*) (soff))->~G__TTGMainFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTransientFrame */
static int G__G__Gui1_216_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTransientFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTransientFrame(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTransientFrame(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTransientFrame(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTransientFrame(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTransientFrame(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTransientFrame(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTransientFrame((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTransientFrame((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTransientFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTransientFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTransientFrame[n];
       } else {
         p = new((void*) gvp) TGTransientFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTransientFrame;
       } else {
         p = new((void*) gvp) TGTransientFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTransientFrame*) G__getstructoffset())->CenterOnParent((Bool_t) G__int(libp->para[0]), (TGTransientFrame::EPlacement) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTransientFrame*) G__getstructoffset())->CenterOnParent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTransientFrame*) G__getstructoffset())->CenterOnParent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTransientFrame*) G__getstructoffset())->GetMain());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTransientFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTransientFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTransientFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTransientFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTransientFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTransientFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTransientFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTransientFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_216_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTransientFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTransientFrame G__TTGTransientFrame;
static int G__G__Gui1_216_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[] (TGTransientFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTransientFrame*) (soff+(sizeof(TGTransientFrame)*i)))->~G__TTGTransientFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTransientFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTransientFrame*) (soff))->~G__TTGTransientFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGGroupFrame */
static int G__G__Gui1_218_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGGroupFrame::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGGroupFrame::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGGroupFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGGroupFrame((TGWindow*) G__int(libp->para[0]), (TGString*) 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__Gui1LN_TGGroupFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGGroupFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGGroupFrame(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGroupFrame((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGGroupFrame((TGWindow*) 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 TGGroupFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGGroupFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGGroupFrame[n];
       } else {
         p = new((void*) gvp) TGGroupFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGGroupFrame;
       } else {
         p = new((void*) gvp) TGGroupFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGroupFrame*) G__getstructoffset())->SetTitle((TGString*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGroupFrame*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGroupFrame*) G__getstructoffset())->Rename((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGGroupFrame*) G__getstructoffset())->GetTitlePos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGGroupFrame*) G__getstructoffset())->SetTitlePos((TGGroupFrame::ETitlePos) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGGroupFrame*) G__getstructoffset())->SetTitlePos();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGGroupFrame*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGGroupFrame*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGGroupFrame*) G__getstructoffset())->SetTextFont((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGGroupFrame*) G__getstructoffset())->SetTextFont((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGGroupFrame*) G__getstructoffset())->SetTextFont((FontStruct_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGGroupFrame*) G__getstructoffset())->SetTextFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGGroupFrame*) G__getstructoffset())->GetNormGC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGGroupFrame*) G__getstructoffset())->GetFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGGroupFrame*) G__getstructoffset())->HasOwnFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGGroupFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGroupFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGGroupFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGGroupFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGroupFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGroupFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGGroupFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGroupFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_218_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGGroupFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGGroupFrame G__TTGGroupFrame;
static int G__G__Gui1_218_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[] (TGGroupFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGGroupFrame*) (soff+(sizeof(TGGroupFrame)*i)))->~G__TTGGroupFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGGroupFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGGroupFrame*) (soff))->~G__TTGGroupFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHeaderFrame */
static int G__G__Gui1_220_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHeaderFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGHeaderFrame(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHeaderFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHeaderFrame((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHeaderFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHeaderFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHeaderFrame[n];
       } else {
         p = new((void*) gvp) TGHeaderFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHeaderFrame;
       } else {
         p = new((void*) gvp) TGHeaderFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHeaderFrame*) G__getstructoffset())->SetColumnsInfo((Int_t) G__int(libp->para[0]), (TGTextButton**) G__int(libp->para[1])
, (TGVFileSplitter**) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHeaderFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHeaderFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHeaderFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHeaderFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHeaderFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHeaderFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHeaderFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHeaderFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_220_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHeaderFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHeaderFrame G__TTGHeaderFrame;
static int G__G__Gui1_220_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[] (TGHeaderFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHeaderFrame*) (soff+(sizeof(TGHeaderFrame)*i)))->~G__TTGHeaderFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHeaderFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHeaderFrame*) (soff))->~G__TTGHeaderFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGWidget */
static int G__G__Gui1_224_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGWidget* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWidget[n];
     } else {
       p = new((void*) gvp) TGWidget[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGWidget;
     } else {
       p = new((void*) gvp) TGWidget;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGWidget));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGWidget* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGWidget((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGWidget((Int_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__Gui1LN_TGWidget));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGWidget*) G__getstructoffset())->WidgetId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGWidget*) G__getstructoffset())->IsEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGWidget*) G__getstructoffset())->HasFocus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGWidget*) G__getstructoffset())->WantFocus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWidget*) G__getstructoffset())->Associate((TGWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWidget*) G__getstructoffset())->SetCommand((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGWidget*) G__getstructoffset())->GetCommand());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGWidget::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGWidget::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGWidget::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGWidget::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGWidget*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWidget*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWidget*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGWidget*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGWidget::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGWidget::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGWidget::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_224_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGWidget::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGWidget G__TTGWidget;
static int G__G__Gui1_224_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[] (TGWidget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGWidget*) (soff+(sizeof(TGWidget)*i)))->~G__TTGWidget();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGWidget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGWidget*) (soff))->~G__TTGWidget();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGIcon */
static int G__G__Gui1_226_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGIcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIcon(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGIcon(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIcon(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGIcon(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIcon(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGIcon(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGIcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGIcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIcon((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGIcon((TGWindow*) 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 TGIcon((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGIcon((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGIcon[n];
       } else {
         p = new((void*) gvp) TGIcon[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGIcon;
       } else {
         p = new((void*) gvp) TGIcon;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGIcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGIcon*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGIcon*) G__getstructoffset())->GetImage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->SetPicture((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->SetImage((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->SetImage((TImage*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->SetImagePath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->ChangeBackgroundColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGIcon::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIcon::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGIcon::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGIcon::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIcon*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIcon::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGIcon::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIcon::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_226_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGIcon::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGIcon G__TTGIcon;
static int G__G__Gui1_226_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGIcon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGIcon*) (soff+(sizeof(TGIcon)*i)))->~G__TTGIcon();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGIcon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGIcon*) (soff))->~G__TTGIcon();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLabel */
static int G__G__Gui1_228_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGLabel::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGLabel::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLabel* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLabel((TGWindow*) G__int(libp->para[0]), (TGString*) 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__Gui1LN_TGLabel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLabel* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLabel(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLabel((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLabel((TGWindow*) 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 TGLabel((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLabel((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLabel[n];
       } else {
         p = new((void*) gvp) TGLabel[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLabel;
       } else {
         p = new((void*) gvp) TGLabel;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGLabel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLabel*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->SetText((TGString*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->ChangeText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->SetText((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->SetTextJustify((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->GetTextJustify());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLabel*) G__getstructoffset())->SetTextFont((TGFont*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLabel*) G__getstructoffset())->SetTextFont((TGFont*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLabel*) G__getstructoffset())->SetTextFont((FontStruct_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLabel*) G__getstructoffset())->SetTextFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLabel*) G__getstructoffset())->SetTextFont((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLabel*) G__getstructoffset())->SetTextFont((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLabel*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLabel*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLabel*) G__getstructoffset())->SetTextColor((TColor*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLabel*) G__getstructoffset())->SetTextColor((TColor*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLabel*) G__getstructoffset())->Disable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLabel*) G__getstructoffset())->Disable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->Enable();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLabel*) G__getstructoffset())->IsDisabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLabel*) G__getstructoffset())->HasOwnFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->SetWrapLength((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->GetWrapLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->Set3DStyle((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->Get3DStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLabel*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLabel*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLabel*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLabel*) G__getstructoffset())->SetMargins((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLabel*) G__getstructoffset())->SetMargins();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->GetLeftMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->GetRightMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->GetTopMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLabel*) G__getstructoffset())->GetBottomMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGLabel*) G__getstructoffset())->GetNormGC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGLabel*) G__getstructoffset())->GetFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLabel*) G__getstructoffset())->GetFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLabel::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLabel::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLabel::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLabel::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLabel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLabel::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLabel::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLabel::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_228_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLabel::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLabel G__TTGLabel;
static int G__G__Gui1_228_0_55(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[] (TGLabel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLabel*) (soff+(sizeof(TGLabel)*i)))->~G__TTGLabel();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLabel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLabel*) (soff))->~G__TTGLabel();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGButtonGroup */
static int G__G__Gui1_231_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGButtonGroup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TGButtonGroup((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGButtonGroup((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGButtonGroup[n];
       } else {
         p = new((void*) gvp) TGButtonGroup[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGButtonGroup;
       } else {
         p = new((void*) gvp) TGButtonGroup;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGButtonGroup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref
, (GContext_t) G__int(libp->para[6]), (FontStruct_t) G__int(libp->para[7])
, (Pixel_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref
, (GContext_t) G__int(libp->para[6]), (FontStruct_t) G__int(libp->para[7])
, (Pixel_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref
, (GContext_t) G__int(libp->para[6]), (FontStruct_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref
, (GContext_t) G__int(libp->para[6]), (FontStruct_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref
, (GContext_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref
, (GContext_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref);
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref);
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGButtonGroup(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->Pressed((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->Released((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->Clicked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->ButtonPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->ButtonReleased();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->ButtonClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->ReleaseButtons();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButtonGroup*) G__getstructoffset())->IsEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButtonGroup*) G__getstructoffset())->IsExclusive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButtonGroup*) G__getstructoffset())->IsRadioButtonExclusive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButtonGroup*) G__getstructoffset())->IsBorderDrawn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGButtonGroup*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGButtonGroup*) G__getstructoffset())->GetId((TGButton*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGButtonGroup*) G__getstructoffset())->SetExclusive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButtonGroup*) G__getstructoffset())->SetExclusive();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGButtonGroup*) G__getstructoffset())->SetRadioButtonExclusive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButtonGroup*) G__getstructoffset())->SetRadioButtonExclusive();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGButtonGroup*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButtonGroup*) G__getstructoffset())->SetState();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGButtonGroup*) G__getstructoffset())->SetBorderDrawn((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButtonGroup*) G__getstructoffset())->SetBorderDrawn();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGButtonGroup*) G__getstructoffset())->SetButton((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGButtonGroup*) G__getstructoffset())->SetButton((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TGButtonGroup*) G__getstructoffset())->Insert((TGButton*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TGButtonGroup*) G__getstructoffset())->Insert((TGButton*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->Remove((TGButton*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGButtonGroup*) G__getstructoffset())->Find((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGButtonGroup*) G__getstructoffset())->GetButton((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGButtonGroup*) G__getstructoffset())->SetLayoutHints((TGLayoutHints*) G__int(libp->para[0]), (TGButton*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGButtonGroup*) G__getstructoffset())->SetLayoutHints((TGLayoutHints*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGButtonGroup::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGButtonGroup::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGButtonGroup::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGButtonGroup::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButtonGroup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGButtonGroup::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGButtonGroup::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGButtonGroup::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_231_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGButtonGroup::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGButtonGroup G__TTGButtonGroup;
static int G__G__Gui1_231_0_48(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[] (TGButtonGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGButtonGroup*) (soff+(sizeof(TGButtonGroup)*i)))->~G__TTGButtonGroup();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGButtonGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGButtonGroup*) (soff))->~G__TTGButtonGroup();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGPopupMenu */
static int G__G__Gui1_232_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPopupMenu* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPopupMenu(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGPopupMenu(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPopupMenu(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPopupMenu(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPopupMenu((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGPopupMenu((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPopupMenu((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGPopupMenu((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPopupMenu[n];
       } else {
         p = new((void*) gvp) TGPopupMenu[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPopupMenu;
       } else {
         p = new((void*) gvp) TGPopupMenu;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((TGHotString*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGMenuEntry*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((TGHotString*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((TGHotString*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((TGHotString*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGMenuEntry*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGPopupMenu*) G__getstructoffset())->AddEntry((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGPopupMenu*) G__getstructoffset())->AddSeparator((TGMenuEntry*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGPopupMenu*) G__getstructoffset())->AddSeparator();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGPopupMenu*) G__getstructoffset())->AddLabel((TGHotString*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGMenuEntry*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGPopupMenu*) G__getstructoffset())->AddLabel((TGHotString*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGPopupMenu*) G__getstructoffset())->AddLabel((TGHotString*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGPopupMenu*) G__getstructoffset())->AddLabel((const char*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGMenuEntry*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGPopupMenu*) G__getstructoffset())->AddLabel((const char*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGPopupMenu*) G__getstructoffset())->AddLabel((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGPopupMenu*) G__getstructoffset())->AddPopup((TGHotString*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGMenuEntry*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGPopupMenu*) G__getstructoffset())->AddPopup((TGHotString*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGMenuEntry*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGPopupMenu*) G__getstructoffset())->AddPopup((TGHotString*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGPopupMenu*) G__getstructoffset())->AddPopup((const char*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGMenuEntry*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGPopupMenu*) G__getstructoffset())->AddPopup((const char*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGMenuEntry*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGPopupMenu*) G__getstructoffset())->AddPopup((const char*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->EnableEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->DisableEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGPopupMenu*) G__getstructoffset())->IsEntryEnabled((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->HideEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGPopupMenu*) G__getstructoffset())->IsEntryHidden((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->DefaultEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->CheckEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->CheckEntryByData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->UnCheckEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->UnCheckEntryByData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->UnCheckEntries();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGPopupMenu*) G__getstructoffset())->IsEntryChecked((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->RCheckEntry((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__Gui1_232_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGPopupMenu*) G__getstructoffset())->IsEntryRChecked((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->PlaceMenu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) 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__Gui1_232_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGPopupMenu*) G__getstructoffset())->EndMenu(libp->para[0].ref ? *(void**) libp->para[0].ref : *(void**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->DeleteEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->DeleteEntry((TGMenuEntry*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGPopupMenu*) G__getstructoffset())->GetEntry((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPopupMenu*) G__getstructoffset())->GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGPopupMenu*) G__getstructoffset())->GetEntry((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPopupMenu*) G__getstructoffset())->GetListOfEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->Associate((TGWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->SetMenuBar((TGMenuBar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPopupMenu*) G__getstructoffset())->GetMenuBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->Activate((TGMenuEntry*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGPopupMenu*) G__getstructoffset())->GetEntrySep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->SetEntrySep((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->PoppedUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->PoppedDown();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->Highlighted((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->Activated((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGPopupMenu::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPopupMenu::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGPopupMenu::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGPopupMenu::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPopupMenu*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPopupMenu::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPopupMenu::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPopupMenu::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_232_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPopupMenu::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGPopupMenu G__TTGPopupMenu;
static int G__G__Gui1_232_0_73(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[] (TGPopupMenu*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPopupMenu*) (soff+(sizeof(TGPopupMenu)*i)))->~G__TTGPopupMenu();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPopupMenu*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPopupMenu*) (soff))->~G__TTGPopupMenu();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGButton */
static int G__G__Gui1_233_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGButton::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGButton::GetHibckgndGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButton(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGButton(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButton(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGButton(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (GContext_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButton((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGButton((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGButton((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGButton((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGButton[n];
       } else {
         p = new((void*) gvp) TGButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGButton;
       } else {
         p = new((void*) gvp) TGButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->SetUserData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TGButton*) G__getstructoffset())->GetUserData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGButton*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGButton*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGButton*) G__getstructoffset())->GetToolTip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGButton*) G__getstructoffset())->SetState((EButtonState) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGButton*) G__getstructoffset())->SetState((EButtonState) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGButton*) G__getstructoffset())->GetState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->AllowStayDown((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->SetGroup((TGButtonGroup*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGButton*) G__getstructoffset())->GetGroup());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButton*) G__getstructoffset())->IsDown());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGButton*) G__getstructoffset())->SetDown((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGButton*) G__getstructoffset())->SetDown((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButton*) G__getstructoffset())->SetDown();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButton*) G__getstructoffset())->IsOn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGButton*) G__getstructoffset())->SetOn((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGButton*) G__getstructoffset())->SetOn((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButton*) G__getstructoffset())->SetOn();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButton*) G__getstructoffset())->IsToggleButton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGButton*) G__getstructoffset())->IsExclusiveToggle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGButton*) G__getstructoffset())->Toggle((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButton*) G__getstructoffset())->Toggle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGButton*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGButton*) G__getstructoffset())->SetEnabled();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGButton*) G__getstructoffset())->GetNormGC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->Pressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->Released();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->Clicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->Toggled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_233_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGButton G__TTGButton;
static int G__G__Gui1_233_0_45(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[] (TGButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGButton*) (soff+(sizeof(TGButton)*i)))->~G__TTGButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGButton*) (soff))->~G__TTGButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGPictureButton */
static int G__G__Gui1_234_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPictureButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) 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 TGPictureButton((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGPictureButton((TGWindow*) G__int(libp->para[0]), (TGPicture*) 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__Gui1LN_TGPictureButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPictureButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPictureButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPictureButton(
(TGWindow*) G__int(libp->para[0]), (const char*) 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 TGPictureButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGPictureButton((TGWindow*) 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 TGPictureButton((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGPictureButton((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPictureButton[n];
       } else {
         p = new((void*) gvp) TGPictureButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPictureButton;
       } else {
         p = new((void*) gvp) TGPictureButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPictureButton*) G__getstructoffset())->SetPicture((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPictureButton*) G__getstructoffset())->SetDisabledPicture((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPictureButton*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGPictureButton*) G__getstructoffset())->GetDisabledPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGPictureButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPictureButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGPictureButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGPictureButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPictureButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPictureButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPictureButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPictureButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_234_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPictureButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGPictureButton G__TTGPictureButton;
static int G__G__Gui1_234_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[] (TGPictureButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPictureButton*) (soff+(sizeof(TGPictureButton)*i)))->~G__TTGPictureButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPictureButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPictureButton*) (soff))->~G__TTGPictureButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGCheckButton */
static int G__G__Gui1_235_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGCheckButton::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGCheckButton::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCheckButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) 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 TGCheckButton((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGCheckButton((TGWindow*) G__int(libp->para[0]), (TGHotString*) 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__Gui1LN_TGCheckButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCheckButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) 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 TGCheckButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGCheckButton((TGWindow*) 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 TGCheckButton((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGCheckButton((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGCheckButton[n];
       } else {
         p = new((void*) gvp) TGCheckButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGCheckButton;
       } else {
         p = new((void*) gvp) TGCheckButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCheckButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGCheckButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGCheckButton*) G__getstructoffset())->IsDisabledAndSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCheckButton*) G__getstructoffset())->SetDisabledAndSelected((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGCheckButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCheckButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGCheckButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGCheckButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCheckButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCheckButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCheckButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCheckButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_235_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCheckButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGCheckButton G__TTGCheckButton;
static int G__G__Gui1_235_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[] (TGCheckButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGCheckButton*) (soff+(sizeof(TGCheckButton)*i)))->~G__TTGCheckButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGCheckButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGCheckButton*) (soff))->~G__TTGCheckButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRadioButton */
static int G__G__Gui1_236_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGRadioButton::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGRadioButton::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRadioButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) 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 TGRadioButton((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGRadioButton((TGWindow*) G__int(libp->para[0]), (TGHotString*) 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__Gui1LN_TGRadioButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRadioButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) 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 TGRadioButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGRadioButton((TGWindow*) 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 TGRadioButton((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGRadioButton((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGRadioButton[n];
       } else {
         p = new((void*) gvp) TGRadioButton[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGRadioButton;
       } else {
         p = new((void*) gvp) TGRadioButton;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRadioButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]), (FontStruct_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRadioButton(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRadioButton*) G__getstructoffset())->SetDisabledAndSelected((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRadioButton*) G__getstructoffset())->IsDisabledAndSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRadioButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRadioButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRadioButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRadioButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRadioButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRadioButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRadioButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRadioButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_236_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRadioButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRadioButton G__TTGRadioButton;
static int G__G__Gui1_236_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[] (TGRadioButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRadioButton*) (soff+(sizeof(TGRadioButton)*i)))->~G__TTGRadioButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRadioButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRadioButton*) (soff))->~G__TTGRadioButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSplitButton */
static int G__G__Gui1_237_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSplitButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGSplitButton(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->SetMBState((EButtonState) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->SetSplit((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGSplitButton*) G__getstructoffset())->IsSplit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->MBPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->MBReleased();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->MBClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->ItemClicked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->HandleMenu((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSplitButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSplitButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSplitButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_237_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSplitButton G__TTGSplitButton;
static int G__G__Gui1_237_0_44(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[] (TGSplitButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSplitButton*) (soff+(sizeof(TGSplitButton)*i)))->~G__TTGSplitButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSplitButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSplitButton*) (soff))->~G__TTGSplitButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextBuffer */
static int G__G__Gui1_238_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextBuffer* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextBuffer[n];
     } else {
       p = new((void*) gvp) TGTextBuffer[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextBuffer;
     } else {
       p = new((void*) gvp) TGTextBuffer;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextBuffer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGTextBuffer((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGTextBuffer((Int_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__Gui1LN_TGTextBuffer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTextBuffer*) G__getstructoffset())->GetTextLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTextBuffer*) G__getstructoffset())->GetBufferLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGTextBuffer*) G__getstructoffset())->GetString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->AddText((Int_t) 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__Gui1_238_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->AddText((Int_t) G__int(libp->para[0]), (const char*) 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__Gui1_238_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->RemoveText((Int_t) 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__Gui1_238_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextBuffer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextBuffer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextBuffer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextBuffer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextBuffer*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextBuffer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextBuffer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextBuffer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextBuffer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_238_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextBuffer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextBuffer G__TTGTextBuffer;
static int G__G__Gui1_238_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[] (TGTextBuffer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextBuffer*) (soff+(sizeof(TGTextBuffer)*i)))->~G__TTGTextBuffer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextBuffer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextBuffer*) (soff))->~G__TTGTextBuffer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextEntry */
static int G__G__Gui1_240_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGTextEntry::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGTextEntry::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) 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 TGTextEntry((TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextEntry((TGWindow*) G__int(libp->para[0]), (TGTextBuffer*) 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__Gui1LN_TGTextEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextEntry(
(TGWindow*) G__int(libp->para[0]), (const char*) 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 TGTextEntry((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextEntry((TGWindow*) 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 TGTextEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextEntry[n];
       } else {
         p = new((void*) gvp) TGTextEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextEntry;
       } else {
         p = new((void*) gvp) TGTextEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEntry(
*(TString*) libp->para[0].ref, (TGWindow*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextEntry(
*(TString*) libp->para[0].ref, (TGWindow*) 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 TGTextEntry(*(TString*) libp->para[0].ref, (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextEntry(*(TString*) libp->para[0].ref, (TGWindow*) 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__Gui1LN_TGTextEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SetDefaultSize((UInt_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__Gui1_240_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->AppendText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->Backspace();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->CursorLeft((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->CursorLeft((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->CursorLeft();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->CursorRight((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->CursorRight((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->CursorRight();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->CursorWordForward((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->CursorWordForward();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->CursorWordBackward((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->CursorWordBackward();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->Cut();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->Del();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->Deselect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->End((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->End();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->GetAlignment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextEntry*) G__getstructoffset())->GetBuffer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->GetCursorPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TGTextEntry*) G__getstructoffset())->GetDisplayText();
         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__Gui1_240_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->GetEchoMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->GetInsertMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TGTextEntry*) G__getstructoffset())->GetMarkedText();
         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__Gui1_240_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->GetMaxLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGTextEntry*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextEntry*) G__getstructoffset())->GetToolTip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextEntry*) G__getstructoffset())->HasMarkedText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTextEntry*) G__getstructoffset())->GetTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTextEntry*) G__getstructoffset())->GetFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->Home((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->Home();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->Insert((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->InsertText((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__Gui1_240_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextEntry*) G__getstructoffset())->IsFrameDrawn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextEntry*) G__getstructoffset())->IsEdited());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->MarkWord((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->MaxMark());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEntry*) G__getstructoffset())->MinMark());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->NewMark((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->Remove();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->RemoveText((Int_t) 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__Gui1_240_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetFont((TGFont*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetFont((TGFont*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetFont((FontStruct_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetFont((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetFont((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetTextColor((TColor*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetTextColor((TColor*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTextEntry*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SetMaxLength((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SelectAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetAlignment((ETextJustification) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->SetAlignment();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetInsertMode((TGTextEntry::EInsertMode) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->SetInsertMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetEchoMode((TGTextEntry::EEchoMode) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->SetEchoMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->SetEnabled();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SetCursorPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetEdited((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->SetEdited();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SetFocus();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->SetFrameDrawn((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->SetFrameDrawn();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextEntry*) G__getstructoffset())->HasOwnFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEntry*) G__getstructoffset())->TextChanged((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEntry*) G__getstructoffset())->TextChanged();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->ReturnPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->TabPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->ShiftTabPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->CursorOutLeft();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->CursorOutRight();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->CursorOutUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->CursorOutDown();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->DoubleClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_240_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextEntry G__TTGTextEntry;
static int G__G__Gui1_240_0_114(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[] (TGTextEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextEntry*) (soff+(sizeof(TGTextEntry)*i)))->~G__TTGTextEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextEntry*) (soff))->~G__TTGTextEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMsgBox */
static int G__G__Gui1_245_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMsgBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_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 TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) 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 TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) 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 TGMsgBox((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGMsgBox((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGMsgBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMsgBox[n];
       } else {
         p = new((void*) gvp) TGMsgBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMsgBox;
       } else {
         p = new((void*) gvp) TGMsgBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMsgBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_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 TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMsgBox(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (EMsgBoxIcon) 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__Gui1LN_TGMsgBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMsgBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMsgBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMsgBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMsgBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMsgBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMsgBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMsgBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMsgBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_245_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMsgBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMsgBox G__TTGMsgBox;
static int G__G__Gui1_245_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[] (TGMsgBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMsgBox*) (soff+(sizeof(TGMsgBox)*i)))->~G__TTGMsgBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMsgBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMsgBox*) (soff))->~G__TTGMsgBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMenuBar */
static int G__G__Gui1_248_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMenuBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGMenuBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMenuBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGMenuBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGMenuBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMenuBar[n];
       } else {
         p = new((void*) gvp) TGMenuBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMenuBar;
       } else {
         p = new((void*) gvp) TGMenuBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGMenuBar*) G__getstructoffset())->AddPopup((TGHotString*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGLayoutHints*) G__int(libp->para[2]), (TGPopupMenu*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGMenuBar*) G__getstructoffset())->AddPopup((TGHotString*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGLayoutHints*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGMenuBar*) G__getstructoffset())->AddPopup((const char*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGLayoutHints*) G__int(libp->para[2]), (TGPopupMenu*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGMenuBar*) G__getstructoffset())->AddPopup((const char*) G__int(libp->para[0]), (TGPopupMenu*) G__int(libp->para[1])
, (TGLayoutHints*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->AddPopup(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->AddPopup(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->AddPopup(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->AddPopup(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->AddPopup(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGMenuBar*) G__getstructoffset())->AddTitle((TGMenuTitle*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGMenuBar*) G__getstructoffset())->AddTitle((TGMenuTitle*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->GetPopup((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->RemovePopup((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuBar*) G__getstructoffset())->GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuBar*) G__getstructoffset())->GetTitles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuBar*) G__getstructoffset())->PopupConnection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGMenuBar*) G__getstructoffset())->GetLastOnLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMenuBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMenuBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMenuBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMenuBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_248_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMenuBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMenuBar G__TTGMenuBar;
static int G__G__Gui1_248_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[] (TGMenuBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMenuBar*) (soff+(sizeof(TGMenuBar)*i)))->~G__TTGMenuBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMenuBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMenuBar*) (soff))->~G__TTGMenuBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMenuTitle */
static int G__G__Gui1_249_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGMenuTitle::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGMenuTitle::GetDefaultSelectedGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGMenuTitle::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMenuTitle* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGMenuTitle(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (TGPopupMenu*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuTitle((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGMenuTitle((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuTitle((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGMenuTitle((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMenuTitle[n];
       } else {
         p = new((void*) gvp) TGMenuTitle[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGMenuTitle;
       } else {
         p = new((void*) gvp) TGMenuTitle;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGMenuTitle*) G__getstructoffset())->GetTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuTitle*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuTitle*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGMenuTitle*) G__getstructoffset())->GetState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMenuTitle*) G__getstructoffset())->GetHotKeyCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuTitle*) G__getstructoffset())->GetMenu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuTitle*) G__getstructoffset())->DoSendMessage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMenuTitle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuTitle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMenuTitle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMenuTitle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuTitle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuTitle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMenuTitle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuTitle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_249_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMenuTitle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMenuTitle G__TTGMenuTitle;
static int G__G__Gui1_249_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[] (TGMenuTitle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMenuTitle*) (soff+(sizeof(TGMenuTitle)*i)))->~G__TTGMenuTitle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMenuTitle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMenuTitle*) (soff))->~G__TTGMenuTitle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGMenuEntry */
static int G__G__Gui1_250_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMenuEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuEntry[n];
     } else {
       p = new((void*) gvp) TGMenuEntry[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGMenuEntry;
     } else {
       p = new((void*) gvp) TGMenuEntry;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMenuEntry*) G__getstructoffset())->GetEntryId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGMenuEntry*) G__getstructoffset())->GetShortcutText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMenuEntry*) G__getstructoffset())->GetStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMenuEntry*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuEntry*) G__getstructoffset())->GetPopup());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuEntry*) G__getstructoffset())->GetLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuEntry*) G__getstructoffset())->GetShortcut());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMenuEntry*) G__getstructoffset())->GetEx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGMenuEntry*) G__getstructoffset())->GetEy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGMenuEntry*) G__getstructoffset())->GetEw());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGMenuEntry*) G__getstructoffset())->GetEh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGMenuEntry*) G__getstructoffset())->GetPic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TGMenuEntry*) G__getstructoffset())->GetUserData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGMenuEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGMenuEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGMenuEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMenuEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMenuEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGMenuEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_250_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGMenuEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGMenuEntry G__TTGMenuEntry;
static int G__G__Gui1_250_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[] (TGMenuEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGMenuEntry*) (soff+(sizeof(TGMenuEntry)*i)))->~G__TTGMenuEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGMenuEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGMenuEntry*) (soff))->~G__TTGMenuEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGShutterItem */
static int G__G__Gui1_261_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGShutterItem* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShutterItem(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGShutterItem(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShutterItem(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGShutterItem(
(TGWindow*) G__int(libp->para[0]), (TGHotString*) 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 TGShutterItem((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGShutterItem((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShutterItem((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGShutterItem((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGShutterItem[n];
       } else {
         p = new((void*) gvp) TGShutterItem[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGShutterItem;
       } else {
         p = new((void*) gvp) TGShutterItem;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGShutterItem*) G__getstructoffset())->GetButton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGShutterItem*) G__getstructoffset())->GetContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutterItem*) G__getstructoffset())->Selected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGShutterItem::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShutterItem::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGShutterItem::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGShutterItem::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutterItem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShutterItem::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGShutterItem::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShutterItem::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_261_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGShutterItem::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGShutterItem G__TTGShutterItem;
static int G__G__Gui1_261_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[] (TGShutterItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGShutterItem*) (soff+(sizeof(TGShutterItem)*i)))->~G__TTGShutterItem();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGShutterItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGShutterItem*) (soff))->~G__TTGShutterItem();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGShutter */
static int G__G__Gui1_262_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGShutter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShutter((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGShutter((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGShutter((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGShutter((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGShutter[n];
       } else {
         p = new((void*) gvp) TGShutter[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGShutter;
       } else {
         p = new((void*) gvp) TGShutter;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGShutter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->AddItem((TGShutterItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->RemoveItem((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TGShutter*) G__getstructoffset())->AddPage((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGShutter*) G__getstructoffset())->AddPage());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->RemovePage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->RenamePage((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGShutter*) G__getstructoffset())->GetSelectedItem());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGShutter*) G__getstructoffset())->GetItem((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->SetSelectedItem((TGShutterItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->SetSelectedItem((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGShutter*) G__getstructoffset())->EnableItem((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGShutter*) G__getstructoffset())->EnableItem((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->SetDefaultSize((UInt_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__Gui1_262_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->Selected((TGShutterItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGShutter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShutter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGShutter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGShutter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGShutter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShutter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGShutter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGShutter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_262_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGShutter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGShutter G__TTGShutter;
static int G__G__Gui1_262_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[] (TGShutter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGShutter*) (soff+(sizeof(TGShutter)*i)))->~G__TTGShutter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGShutter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGShutter*) (soff))->~G__TTGShutter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHorizontal3DLine */
static int G__G__Gui1_263_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHorizontal3DLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontal3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGHorizontal3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontal3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGHorizontal3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontal3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGHorizontal3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontal3DLine((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHorizontal3DLine((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHorizontal3DLine((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHorizontal3DLine((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHorizontal3DLine[n];
       } else {
         p = new((void*) gvp) TGHorizontal3DLine[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHorizontal3DLine;
       } else {
         p = new((void*) gvp) TGHorizontal3DLine;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHorizontal3DLine::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontal3DLine::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHorizontal3DLine::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHorizontal3DLine::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHorizontal3DLine*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontal3DLine::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHorizontal3DLine::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHorizontal3DLine::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_263_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHorizontal3DLine::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHorizontal3DLine G__TTGHorizontal3DLine;
static int G__G__Gui1_263_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[] (TGHorizontal3DLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHorizontal3DLine*) (soff+(sizeof(TGHorizontal3DLine)*i)))->~G__TTGHorizontal3DLine();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHorizontal3DLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHorizontal3DLine*) (soff))->~G__TTGHorizontal3DLine();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVertical3DLine */
static int G__G__Gui1_264_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVertical3DLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVertical3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGVertical3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVertical3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGVertical3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVertical3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGVertical3DLine(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVertical3DLine((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVertical3DLine((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVertical3DLine((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVertical3DLine((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVertical3DLine[n];
       } else {
         p = new((void*) gvp) TGVertical3DLine[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVertical3DLine;
       } else {
         p = new((void*) gvp) TGVertical3DLine;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVertical3DLine::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVertical3DLine::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVertical3DLine::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVertical3DLine::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVertical3DLine*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVertical3DLine::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVertical3DLine::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVertical3DLine::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_264_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVertical3DLine::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVertical3DLine G__TTGVertical3DLine;
static int G__G__Gui1_264_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[] (TGVertical3DLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVertical3DLine*) (soff+(sizeof(TGVertical3DLine)*i)))->~G__TTGVertical3DLine();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVertical3DLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVertical3DLine*) (soff))->~G__TTGVertical3DLine();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGProgressBar */
static int G__G__Gui1_265_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGProgressBar::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGProgressBar::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGProgressBar*) G__getstructoffset())->GetMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGProgressBar*) G__getstructoffset())->GetMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGProgressBar*) G__getstructoffset())->GetPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGProgressBar*) G__getstructoffset())->GetFillType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGProgressBar*) G__getstructoffset())->GetBarType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGProgressBar*) G__getstructoffset())->GetShowPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TGProgressBar*) G__getstructoffset())->GetFormat();
         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__Gui1_265_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGProgressBar*) G__getstructoffset())->GetValueFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGProgressBar*) G__getstructoffset())->UsePercent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGProgressBar*) G__getstructoffset())->GetBarColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGProgressBar*) G__getstructoffset())->GetNormGC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGProgressBar*) G__getstructoffset())->GetFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetPosition((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetRange((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->Increment((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetBarType((TGProgressBar::EBarType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetFillType((TGProgressBar::EFillType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->Percent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->ShowPos((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGProgressBar*) G__getstructoffset())->Format((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGProgressBar*) G__getstructoffset())->Format();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetMin((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetMax((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->SetBarColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGProgressBar*) G__getstructoffset())->SetBarColor((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGProgressBar*) G__getstructoffset())->SetBarColor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGProgressBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGProgressBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGProgressBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGProgressBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGProgressBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGProgressBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGProgressBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGProgressBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_265_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGProgressBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGProgressBar G__TTGProgressBar;
static int G__G__Gui1_265_0_44(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[] (TGProgressBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGProgressBar*) (soff+(sizeof(TGProgressBar)*i)))->~G__TTGProgressBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGProgressBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGProgressBar*) (soff))->~G__TTGProgressBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHProgressBar */
static int G__G__Gui1_269_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHProgressBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHProgressBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHProgressBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHProgressBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHProgressBar[n];
       } else {
         p = new((void*) gvp) TGHProgressBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHProgressBar;
       } else {
         p = new((void*) gvp) TGHProgressBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHProgressBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (TGProgressBar::EBarType) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGHProgressBar(
(TGWindow*) G__int(libp->para[0]), (TGProgressBar::EBarType) G__int(libp->para[1])
, (UInt_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__Gui1LN_TGHProgressBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGHProgressBar*) G__getstructoffset())->ShowPosition((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGHProgressBar*) G__getstructoffset())->ShowPosition((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGHProgressBar*) G__getstructoffset())->ShowPosition((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGHProgressBar*) G__getstructoffset())->ShowPosition();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHProgressBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHProgressBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHProgressBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHProgressBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHProgressBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHProgressBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHProgressBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHProgressBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_269_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHProgressBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHProgressBar G__TTGHProgressBar;
static int G__G__Gui1_269_0_19(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[] (TGHProgressBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHProgressBar*) (soff+(sizeof(TGHProgressBar)*i)))->~G__TTGHProgressBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHProgressBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHProgressBar*) (soff))->~G__TTGHProgressBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVProgressBar */
static int G__G__Gui1_270_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVProgressBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVProgressBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVProgressBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVProgressBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVProgressBar[n];
       } else {
         p = new((void*) gvp) TGVProgressBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVProgressBar;
       } else {
         p = new((void*) gvp) TGVProgressBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVProgressBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (TGProgressBar::EBarType) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGVProgressBar(
(TGWindow*) G__int(libp->para[0]), (TGProgressBar::EBarType) G__int(libp->para[1])
, (UInt_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__Gui1LN_TGVProgressBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVProgressBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVProgressBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVProgressBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVProgressBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVProgressBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVProgressBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVProgressBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVProgressBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_270_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVProgressBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVProgressBar G__TTGVProgressBar;
static int G__G__Gui1_270_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[] (TGVProgressBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVProgressBar*) (soff+(sizeof(TGVProgressBar)*i)))->~G__TTGVProgressBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVProgressBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVProgressBar*) (soff))->~G__TTGVProgressBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVButtonGroup */
static int G__G__Gui1_276_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVButtonGroup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGVButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGVButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGVButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVButtonGroup((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TGVButtonGroup((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVButtonGroup((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVButtonGroup((TGWindow*) 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__Gui1LN_TGVButtonGroup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVButtonGroup::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVButtonGroup::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVButtonGroup::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVButtonGroup::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVButtonGroup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVButtonGroup::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVButtonGroup::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVButtonGroup::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_276_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVButtonGroup::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVButtonGroup G__TTGVButtonGroup;
static int G__G__Gui1_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGVButtonGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVButtonGroup*) (soff+(sizeof(TGVButtonGroup)*i)))->~G__TTGVButtonGroup();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVButtonGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVButtonGroup*) (soff))->~G__TTGVButtonGroup();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHButtonGroup */
static int G__G__Gui1_277_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHButtonGroup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGHButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGHButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]), (FontStruct_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGHButtonGroup(
(TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (GContext_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHButtonGroup((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TGHButtonGroup((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHButtonGroup((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHButtonGroup((TGWindow*) 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__Gui1LN_TGHButtonGroup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHButtonGroup::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHButtonGroup::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHButtonGroup::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHButtonGroup::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHButtonGroup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHButtonGroup::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHButtonGroup::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHButtonGroup::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_277_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHButtonGroup::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHButtonGroup G__TTGHButtonGroup;
static int G__G__Gui1_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGHButtonGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHButtonGroup*) (soff+(sizeof(TGHButtonGroup)*i)))->~G__TTGHButtonGroup();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHButtonGroup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHButtonGroup*) (soff))->~G__TTGHButtonGroup();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGNumberFormat */
static int G__G__Gui1_278_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGNumberFormat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberFormat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGNumberFormat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGNumberFormat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGNumberFormat*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberFormat*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberFormat*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberFormat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberFormat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberFormat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberFormat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_278_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberFormat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__G__Gui1_278_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGNumberFormat *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberFormat[n];
     } else {
       p = new((void*) gvp) TGNumberFormat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberFormat;
     } else {
       p = new((void*) gvp) TGNumberFormat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui1_278_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGNumberFormat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGNumberFormat(*(TGNumberFormat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGNumberFormat G__TTGNumberFormat;
static int G__G__Gui1_278_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[] (TGNumberFormat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGNumberFormat*) (soff+(sizeof(TGNumberFormat)*i)))->~G__TTGNumberFormat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGNumberFormat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGNumberFormat*) (soff))->~G__TTGNumberFormat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui1_278_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGNumberFormat* dest = (TGNumberFormat*) G__getstructoffset();
   *dest = *(TGNumberFormat*) libp->para[0].ref;
   const TGNumberFormat& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGNumberEntryField */
static int G__G__Gui1_283_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGNumberEntryField* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3])
, (FontStruct_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGNumberEntryField* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]), (TGNumberFormat::ELimit) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]), (TGNumberFormat::ELimit) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]), (TGNumberFormat::ELimit) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]), (TGNumberFormat::ELimit) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]), (TGNumberFormat::ELimit) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]), (TGNumberFormat::ELimit) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3])
, (TGNumberFormat::EAttribute) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGNumberEntryField(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGNumberEntryField((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntryField((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGNumberEntryField((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGNumberEntryField[n];
       } else {
         p = new((void*) gvp) TGNumberEntryField[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGNumberEntryField;
       } else {
         p = new((void*) gvp) TGNumberEntryField;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->SetNumber((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->SetIntNumber((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->SetTime((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__Gui1_283_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->SetDate((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__Gui1_283_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->SetHexNumber((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGNumberEntryField*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetIntNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGNumberEntryField*) G__getstructoffset())->GetTime(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGNumberEntryField*) G__getstructoffset())->GetDate(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetHexNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetCharWidth((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetCharWidth());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGNumberEntryField*) G__getstructoffset())->IncreaseNumber((TGNumberFormat::EStepSize) 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:
      ((TGNumberEntryField*) G__getstructoffset())->IncreaseNumber((TGNumberFormat::EStepSize) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntryField*) G__getstructoffset())->IncreaseNumber((TGNumberFormat::EStepSize) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntryField*) G__getstructoffset())->IncreaseNumber();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGNumberEntryField*) G__getstructoffset())->SetFormat((TGNumberFormat::EStyle) G__int(libp->para[0]), (TGNumberFormat::EAttribute) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntryField*) G__getstructoffset())->SetFormat((TGNumberFormat::EStyle) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGNumberEntryField*) G__getstructoffset())->SetLimits((TGNumberFormat::ELimit) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGNumberEntryField*) G__getstructoffset())->SetLimits((TGNumberFormat::ELimit) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntryField*) G__getstructoffset())->SetLimits((TGNumberFormat::ELimit) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntryField*) G__getstructoffset())->SetLimits();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGNumberEntryField*) G__getstructoffset())->SetLogStep((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntryField*) G__getstructoffset())->SetLogStep();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetNumStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetNumAttr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGNumberEntryField*) G__getstructoffset())->GetNumLimits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGNumberEntryField*) G__getstructoffset())->GetNumMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGNumberEntryField*) G__getstructoffset())->GetNumMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGNumberEntryField*) G__getstructoffset())->IsLogStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->InvalidInput((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGNumberEntryField::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntryField::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGNumberEntryField::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGNumberEntryField::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryField*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntryField::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberEntryField::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntryField::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_283_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberEntryField::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGNumberEntryField G__TTGNumberEntryField;
static int G__G__Gui1_283_0_46(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[] (TGNumberEntryField*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGNumberEntryField*) (soff+(sizeof(TGNumberEntryField)*i)))->~G__TTGNumberEntryField();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGNumberEntryField*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGNumberEntryField*) (soff))->~G__TTGNumberEntryField();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGNumberEntry */
static int G__G__Gui1_284_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGNumberEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5])
, (TGNumberFormat::ELimit) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5])
, (TGNumberFormat::ELimit) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5])
, (TGNumberFormat::ELimit) G__int(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5])
, (TGNumberFormat::ELimit) G__int(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5])
, (TGNumberFormat::ELimit) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5])
, (TGNumberFormat::ELimit) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]), (TGNumberFormat::EAttribute) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGNumberFormat::EStyle) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGNumberEntry(
(TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry((TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TGNumberEntry((TGWindow*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGNumberEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGNumberEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGNumberEntry[n];
       } else {
         p = new((void*) gvp) TGNumberEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGNumberEntry;
       } else {
         p = new((void*) gvp) TGNumberEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetNumber((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetIntNumber((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetTime((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__Gui1_284_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetDate((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__Gui1_284_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetHexNumber((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->SetState();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGNumberEntry*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGNumberEntry*) G__getstructoffset())->GetIntNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGNumberEntry*) G__getstructoffset())->GetTime(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGNumberEntry*) G__getstructoffset())->GetDate(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGNumberEntry*) G__getstructoffset())->GetHexNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGNumberEntry*) G__getstructoffset())->IncreaseNumber((TGNumberFormat::EStepSize) 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:
      ((TGNumberEntry*) G__getstructoffset())->IncreaseNumber((TGNumberFormat::EStepSize) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->IncreaseNumber((TGNumberFormat::EStepSize) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->IncreaseNumber();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGNumberEntry*) G__getstructoffset())->SetFormat((TGNumberFormat::EStyle) G__int(libp->para[0]), (TGNumberFormat::EAttribute) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetFormat((TGNumberFormat::EStyle) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGNumberEntry*) G__getstructoffset())->SetLimits((TGNumberFormat::ELimit) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGNumberEntry*) G__getstructoffset())->SetLimits((TGNumberFormat::ELimit) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetLimits((TGNumberFormat::ELimit) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->SetLimits();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGNumberEntry*) G__getstructoffset())->GetNumStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGNumberEntry*) G__getstructoffset())->GetNumAttr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGNumberEntry*) G__getstructoffset())->GetNumLimits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGNumberEntry*) G__getstructoffset())->GetNumMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGNumberEntry*) G__getstructoffset())->GetNumMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGNumberEntry*) G__getstructoffset())->IsLogStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetButtonToNum((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->SetNumStyle((TGNumberFormat::EStyle) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetNumAttr((TGNumberFormat::EAttribute) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->SetNumAttr();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetNumLimits((TGNumberFormat::ELimit) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->SetNumLimits();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGNumberEntry*) G__getstructoffset())->SetLimitValues((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetLimitValues((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->SetLimitValues();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGNumberEntry*) G__getstructoffset())->SetLogStep((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGNumberEntry*) G__getstructoffset())->SetLogStep();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->ValueChanged((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->ValueSet((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGNumberEntry*) G__getstructoffset())->GetNumberEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGNumberEntry*) G__getstructoffset())->GetButtonUp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGNumberEntry*) G__getstructoffset())->GetButtonDown());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGNumberEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGNumberEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGNumberEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_284_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGNumberEntry G__TTGNumberEntry;
static int G__G__Gui1_284_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[] (TGNumberEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGNumberEntry*) (soff+(sizeof(TGNumberEntry)*i)))->~G__TTGNumberEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGNumberEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGNumberEntry*) (soff))->~G__TTGNumberEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGNumberEntryLayout */
static int G__G__Gui1_285_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGNumberEntryLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGNumberEntryLayout((TGNumberEntry*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGNumberEntryLayout((TGNumberEntry*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGNumberEntryLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntryLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGNumberEntryLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGNumberEntryLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGNumberEntryLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntryLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberEntryLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGNumberEntryLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_285_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGNumberEntryLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGNumberEntryLayout G__TTGNumberEntryLayout;
static int G__G__Gui1_285_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[] (TGNumberEntryLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGNumberEntryLayout*) (soff+(sizeof(TGNumberEntryLayout)*i)))->~G__TTGNumberEntryLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGNumberEntryLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGNumberEntryLayout*) (soff))->~G__TTGNumberEntryLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTableLayoutHints */
static int G__G__Gui1_287_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableLayoutHints* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (ULong_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableLayoutHints(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTableLayoutHints*) G__getstructoffset())->GetAttachLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTableLayoutHints*) G__getstructoffset())->GetAttachRight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTableLayoutHints*) G__getstructoffset())->GetAttachTop());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTableLayoutHints*) G__getstructoffset())->GetAttachBottom());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTableLayoutHints::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableLayoutHints::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTableLayoutHints::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTableLayoutHints::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableLayoutHints*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableLayoutHints::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableLayoutHints::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableLayoutHints::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_287_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableLayoutHints::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTableLayoutHints G__TTGTableLayoutHints;
static int G__G__Gui1_287_0_21(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[] (TGTableLayoutHints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTableLayoutHints*) (soff+(sizeof(TGTableLayoutHints)*i)))->~G__TTGTableLayoutHints();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTableLayoutHints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTableLayoutHints*) (soff))->~G__TTGTableLayoutHints();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTableLayout */
static int G__G__Gui1_288_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTableLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTableLayout(
(TGCompositeFrame*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTableLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTableLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTableLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTableLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTableLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_288_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTableLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTableLayout G__TTGTableLayout;
static int G__G__Gui1_288_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[] (TGTableLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTableLayout*) (soff+(sizeof(TGTableLayout)*i)))->~G__TTGTableLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTableLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTableLayout*) (soff))->~G__TTGTableLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGInputDialog */
static int G__G__Gui1_290_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGInputDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) 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 TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGInputDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) 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 TGInputDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGInputDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGInputDialog((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGInputDialog((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGInputDialog[n];
       } else {
         p = new((void*) gvp) TGInputDialog[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGInputDialog;
       } else {
         p = new((void*) gvp) TGInputDialog;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGInputDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGInputDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGInputDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGInputDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGInputDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGInputDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGInputDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGInputDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_290_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGInputDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGInputDialog G__TTGInputDialog;
static int G__G__Gui1_290_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGInputDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGInputDialog*) (soff+(sizeof(TGInputDialog)*i)))->~G__TTGInputDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGInputDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGInputDialog*) (soff))->~G__TTGInputDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFrameElementPack */
static int G__G__Gui1_292_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFrameElementPack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrameElementPack(
(TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFrameElementPack(
(TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrameElementPack((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFrameElementPack((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFrameElementPack((TGFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFrameElementPack((TGFrame*) 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__Gui1LN_TGFrameElementPack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFrameElementPack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrameElementPack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFrameElementPack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFrameElementPack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFrameElementPack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrameElementPack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFrameElementPack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFrameElementPack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_292_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFrameElementPack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFrameElementPack G__TTGFrameElementPack;
static int G__G__Gui1_292_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[] (TGFrameElementPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFrameElementPack*) (soff+(sizeof(TGFrameElementPack)*i)))->~G__TTGFrameElementPack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFrameElementPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFrameElementPack*) (soff))->~G__TTGFrameElementPack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGPack */
static int G__G__Gui1_293_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGPack(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGPack(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPack(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGPack((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGPack((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPack[n];
       } else {
         p = new((void*) gvp) TGPack[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPack;
       } else {
         p = new((void*) gvp) TGPack;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui1LN_TGPack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPack(
(TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1])
, (TGWindow*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPack((TGClient*) G__int(libp->para[0]), (Window_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGPack((TGClient*) G__int(libp->para[0]), (Window_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__Gui1LN_TGPack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->AddFrameWithWeight((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->DeleteFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->EqualizeFrames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->HandleSplitterStart();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->HandleSplitterResize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGPack*) G__getstructoffset())->GetVertical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->SetVertical((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGPack*) G__getstructoffset())->GetUseSplitters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->SetUseSplitters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGPack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGPack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGPack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1_293_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGPack G__TTGPack;
static int G__G__Gui1_293_0_46(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[] (TGPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPack*) (soff+(sizeof(TGPack)*i)))->~G__TTGPack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPack*) (soff))->~G__TTGPack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Gui1__0_340(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) MK_MSG((EWidgetMessageTypes) G__int(libp->para[0]), (EWidgetMessageTypes) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1__0_341(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) GET_MSG((Long_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui1__0_342(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) GET_SUBMSG((Long_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TGClient */

/* TGObject */

/* TGWindow */

/* TGPicturePool */

/* TGPicture */

/* TGGCPool */

/* TGGC */

/* TGUnknownWindowHandler */

/* TGIdleHandler */

/* TGSelectedPicture */

/* TGDimension */

/* TGPosition */

/* TGLongPosition */

/* TGInsets */

/* TGRectangle */

/* TGFrame */

/* TGCompositeFrame */

/* TGLayoutHints */

/* TGFrameElement */

/* TGLayoutManager */

/* TGVerticalLayout */

/* TGHorizontalLayout */

/* TGRowLayout */

/* TGColumnLayout */

/* TGMatrixLayout */

/* TGTileLayout */

/* TGListLayout */

/* TGListDetailsLayout */

/* TGString */

/* TGHotString */

/* TGTextButton */

/* TGVerticalFrame */

/* TGHorizontalFrame */

/* TGMainFrame */

/* TGTransientFrame */

/* TGGroupFrame */

/* TGHeaderFrame */

/* TGWidget */

/* TGIcon */

/* TGLabel */

/* TGButtonGroup */

/* TGPopupMenu */

/* TGButton */

/* TGPictureButton */

/* TGCheckButton */

/* TGRadioButton */

/* TGSplitButton */

/* TGTextBuffer */

/* TGTextEntry */

/* TGMsgBox */

/* TGMenuBar */

/* TGMenuTitle */

/* TGMenuEntry */

/* TGShutterItem */

/* TGShutter */

/* TGHorizontal3DLine */

/* TGVertical3DLine */

/* TGProgressBar */

/* TGHProgressBar */

/* TGVProgressBar */

/* TGVButtonGroup */

/* TGHButtonGroup */

/* TGNumberFormat */

/* TGNumberEntryField */

/* TGNumberEntry */

/* TGNumberEntryLayout */

/* TGTableLayoutHints */

/* TGTableLayout */

/* TGInputDialog */

/* TGFrameElementPack */

/* TGPack */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Gui1 {
 public:
  G__Sizep2memfuncG__Gui1(): p(&G__Sizep2memfuncG__Gui1::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Gui1::*p)();
};

size_t G__get_sizep2memfuncG__Gui1()
{
  G__Sizep2memfuncG__Gui1 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__Gui1() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGClient))) {
     TGClient *G__Lderived;
     G__Lderived=(TGClient*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGClient),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGClient),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGObject))) {
     TGObject *G__Lderived;
     G__Lderived=(TGObject*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGObject),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGWindow))) {
     TGWindow *G__Lderived;
     G__Lderived=(TGWindow*)0x1000;
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool))) {
     TGPicturePool *G__Lderived;
     G__Lderived=(TGPicturePool*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGPicture))) {
     TGPicture *G__Lderived;
     G__Lderived=(TGPicture*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),G__get_linked_tagnum(&G__G__Gui1LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool))) {
     TGGCPool *G__Lderived;
     G__Lderived=(TGGCPool*)0x1000;
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGGC))) {
     TGGC *G__Lderived;
     G__Lderived=(TGGC*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGC),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGC),G__get_linked_tagnum(&G__G__Gui1LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGUnknownWindowHandler))) {
     TGUnknownWindowHandler *G__Lderived;
     G__Lderived=(TGUnknownWindowHandler*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGUnknownWindowHandler),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler))) {
     TGIdleHandler *G__Lderived;
     G__Lderived=(TGIdleHandler*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture))) {
     TGSelectedPicture *G__Lderived;
     G__Lderived=(TGSelectedPicture*)0x1000;
     {
       TGPicture *G__Lpbase=(TGPicture*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture),G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture),G__get_linked_tagnum(&G__G__Gui1LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame))) {
     TGFrame *G__Lderived;
     G__Lderived=(TGFrame*)0x1000;
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame))) {
     TGCompositeFrame *G__Lderived;
     G__Lderived=(TGCompositeFrame*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints))) {
     TGLayoutHints *G__Lderived;
     G__Lderived=(TGLayoutHints*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),G__get_linked_tagnum(&G__G__Gui1LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement))) {
     TGFrameElement *G__Lderived;
     G__Lderived=(TGFrameElement*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager))) {
     TGLayoutManager *G__Lderived;
     G__Lderived=(TGLayoutManager*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout))) {
     TGVerticalLayout *G__Lderived;
     G__Lderived=(TGVerticalLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout))) {
     TGHorizontalLayout *G__Lderived;
     G__Lderived=(TGHorizontalLayout*)0x1000;
     {
       TGVerticalLayout *G__Lpbase=(TGVerticalLayout*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout))) {
     TGRowLayout *G__Lderived;
     G__Lderived=(TGRowLayout*)0x1000;
     {
       TGVerticalLayout *G__Lpbase=(TGVerticalLayout*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout))) {
     TGColumnLayout *G__Lderived;
     G__Lderived=(TGColumnLayout*)0x1000;
     {
       TGRowLayout *G__Lpbase=(TGRowLayout*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGVerticalLayout *G__Lpbase=(TGVerticalLayout*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout))) {
     TGMatrixLayout *G__Lderived;
     G__Lderived=(TGMatrixLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout))) {
     TGTileLayout *G__Lderived;
     G__Lderived=(TGTileLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout))) {
     TGListLayout *G__Lderived;
     G__Lderived=(TGListLayout*)0x1000;
     {
       TGTileLayout *G__Lpbase=(TGTileLayout*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout))) {
     TGListDetailsLayout *G__Lderived;
     G__Lderived=(TGListDetailsLayout*)0x1000;
     {
       TGTileLayout *G__Lpbase=(TGTileLayout*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGString))) {
     TGString *G__Lderived;
     G__Lderived=(TGString*)0x1000;
     {
       TString *G__Lpbase=(TString*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGString),G__get_linked_tagnum(&G__G__Gui1LN_TString),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHotString))) {
     TGHotString *G__Lderived;
     G__Lderived=(TGHotString*)0x1000;
     {
       TGString *G__Lpbase=(TGString*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHotString),G__get_linked_tagnum(&G__G__Gui1LN_TGString),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TString *G__Lpbase=(TString*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHotString),G__get_linked_tagnum(&G__G__Gui1LN_TString),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton))) {
     TGTextButton *G__Lderived;
     G__Lderived=(TGTextButton*)0x1000;
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame))) {
     TGVerticalFrame *G__Lderived;
     G__Lderived=(TGVerticalFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame))) {
     TGHorizontalFrame *G__Lderived;
     G__Lderived=(TGHorizontalFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame))) {
     TGMainFrame *G__Lderived;
     G__Lderived=(TGMainFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame))) {
     TGTransientFrame *G__Lderived;
     G__Lderived=(TGTransientFrame*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame))) {
     TGGroupFrame *G__Lderived;
     G__Lderived=(TGGroupFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame))) {
     TGHeaderFrame *G__Lderived;
     G__Lderived=(TGHeaderFrame*)0x1000;
     {
       TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon))) {
     TGIcon *G__Lderived;
     G__Lderived=(TGIcon*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel))) {
     TGLabel *G__Lderived;
     G__Lderived=(TGLabel*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup))) {
     TGButtonGroup *G__Lderived;
     G__Lderived=(TGButtonGroup*)0x1000;
     {
       TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu))) {
     TGPopupMenu *G__Lderived;
     G__Lderived=(TGPopupMenu*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGButton))) {
     TGButton *G__Lderived;
     G__Lderived=(TGButton*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton))) {
     TGPictureButton *G__Lderived;
     G__Lderived=(TGPictureButton*)0x1000;
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton))) {
     TGCheckButton *G__Lderived;
     G__Lderived=(TGCheckButton*)0x1000;
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton))) {
     TGRadioButton *G__Lderived;
     G__Lderived=(TGRadioButton*)0x1000;
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton))) {
     TGSplitButton *G__Lderived;
     G__Lderived=(TGSplitButton*)0x1000;
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry))) {
     TGTextEntry *G__Lderived;
     G__Lderived=(TGTextEntry*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox))) {
     TGMsgBox *G__Lderived;
     G__Lderived=(TGMsgBox*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar))) {
     TGMenuBar *G__Lderived;
     G__Lderived=(TGMenuBar*)0x1000;
     {
       TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle))) {
     TGMenuTitle *G__Lderived;
     G__Lderived=(TGMenuTitle*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry))) {
     TGMenuEntry *G__Lderived;
     G__Lderived=(TGMenuEntry*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem))) {
     TGShutterItem *G__Lderived;
     G__Lderived=(TGShutterItem*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter))) {
     TGShutter *G__Lderived;
     G__Lderived=(TGShutter*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine))) {
     TGHorizontal3DLine *G__Lderived;
     G__Lderived=(TGHorizontal3DLine*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine))) {
     TGVertical3DLine *G__Lderived;
     G__Lderived=(TGVertical3DLine*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar))) {
     TGProgressBar *G__Lderived;
     G__Lderived=(TGProgressBar*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar))) {
     TGHProgressBar *G__Lderived;
     G__Lderived=(TGHProgressBar*)0x1000;
     {
       TGProgressBar *G__Lpbase=(TGProgressBar*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar))) {
     TGVProgressBar *G__Lderived;
     G__Lderived=(TGVProgressBar*)0x1000;
     {
       TGProgressBar *G__Lpbase=(TGProgressBar*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup))) {
     TGVButtonGroup *G__Lderived;
     G__Lderived=(TGVButtonGroup*)0x1000;
     {
       TGButtonGroup *G__Lpbase=(TGButtonGroup*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup))) {
     TGHButtonGroup *G__Lderived;
     G__Lderived=(TGHButtonGroup*)0x1000;
     {
       TGButtonGroup *G__Lpbase=(TGButtonGroup*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField))) {
     TGNumberEntryField *G__Lderived;
     G__Lderived=(TGNumberEntryField*)0x1000;
     {
       TGTextEntry *G__Lpbase=(TGTextEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGNumberFormat *G__Lpbase=(TGNumberFormat*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry))) {
     TGNumberEntry *G__Lderived;
     G__Lderived=(TGNumberEntry*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGNumberFormat *G__Lpbase=(TGNumberFormat*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout))) {
     TGNumberEntryLayout *G__Lderived;
     G__Lderived=(TGNumberEntryLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints))) {
     TGTableLayoutHints *G__Lderived;
     G__Lderived=(TGTableLayoutHints*)0x1000;
     {
       TGLayoutHints *G__Lpbase=(TGLayoutHints*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints),G__get_linked_tagnum(&G__G__Gui1LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout))) {
     TGTableLayout *G__Lderived;
     G__Lderived=(TGTableLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout),G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog))) {
     TGInputDialog *G__Lderived;
     G__Lderived=(TGInputDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack))) {
     TGFrameElementPack *G__Lderived;
     G__Lderived=(TGFrameElementPack*)0x1000;
     {
       TGFrameElement *G__Lpbase=(TGFrameElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack),G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui1LN_TGPack))) {
     TGPack *G__Lderived;
     G__Lderived=(TGPack*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack),G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack),G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack),G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack),G__get_linked_tagnum(&G__G__Gui1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack),G__get_linked_tagnum(&G__G__Gui1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack),G__get_linked_tagnum(&G__G__Gui1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Gui1() {

   /* Setting up typedef entry */
   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("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Gui1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Gui1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Handle_t",107,-1,0,-1);
   G__setnewtype(-1,"Generic resource handle",0);
   G__search_typename2("Window_t",107,-1,0,-1);
   G__setnewtype(-1,"Window handle",0);
   G__search_typename2("Pixmap_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixmap handle",0);
   G__search_typename2("Drawable_t",107,-1,0,-1);
   G__setnewtype(-1,"Drawable handle",0);
   G__search_typename2("Colormap_t",107,-1,0,-1);
   G__setnewtype(-1,"Colormap handle",0);
   G__search_typename2("FontH_t",107,-1,0,-1);
   G__setnewtype(-1,"Font handle (as opposed to Font_t which is an index)",0);
   G__search_typename2("Atom_t",107,-1,0,-1);
   G__setnewtype(-1,"WM token",0);
   G__search_typename2("GContext_t",107,-1,0,-1);
   G__setnewtype(-1,"Graphics context handle",0);
   G__search_typename2("FontStruct_t",107,-1,0,-1);
   G__setnewtype(-1,"Pointer to font structure",0);
   G__search_typename2("Pixel_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixel value",0);
   G__search_typename2("Mask_t",104,-1,0,-1);
   G__setnewtype(-1,"Structure mask type",0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1LN_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__Gui1LN_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__Gui1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TGClient */
static void G__setup_memvarTGClient(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGClient));
   { TGClient *p; p=(TGClient*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBackColor=",0,"default background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fForeColor=",0,"default foreground color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fHilite=",0,"default hilite color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fShadow=",0,"default shadow color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fSelBackColor=",0,"default selection background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fSelForeColor=",0,"default selection foreground color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fWhite=",0,"white color index");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBlack=",0,"black color index");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,2,"fDefaultRoot=",0,"default root window (base window of display)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,2,"fRoot=",0,"current root window (changing root window allows embedding)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXfd=",0,"file descriptor of connection to server");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGResourcePool),-1,-1,2,"fResourcePool=",0,"global GUI resource pool");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool),-1,-1,2,"fGCPool=",0,"graphics context pool");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFontPool),-1,-1,2,"fFontPool=",0,"font pool");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool),-1,-1,2,"fPicturePool=",0,"pixmap pool");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGMimeTypes),-1,-1,2,"fMimeTypeList=",0,"mimetype list");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Colormap_t"),-1,2,"fDefaultColormap=",0,"default colormap");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGlobalNeedRedraw=",0,"true if at least one window needs to be redrawn");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fForceRedraw=",0,"redraw widgets as soon as possible");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_THashList),-1,-1,2,"fWlist=",0,"list of frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fPlist=",0,"list of popup windows used in HandleMaskEvent()");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fUWHandlers=",0,"list of event handlers for unknown windows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fIdleHandlers=",0,"list of idle handlers");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EGEventType),-1,-1,2,"fWaitForEvent=",0,"event to wait for");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-1,2,"fWaitForWindow=",0,"window in which to wait for event");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGObject */
static void G__setup_memvarTGObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGObject));
   { TGObject *p; p=(TGObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Handle_t"),-1,2,"fId=",0,"X11/Win32 Window identifier");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGClient),-1,-1,2,"fClient=",0,"Connection to display server");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGWindow */
static void G__setup_memvarTGWindow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGWindow));
   { TGWindow *p; p=(TGWindow*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,2,"fParent=",0,"Parent window");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNeedRedraw=",0,"kTRUE if window needs to be redrawn");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fName=",0,"name of the window used in SavePrimitive()");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgCounter=",0,"counter of created windows in SavePrimitive");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEditDisabled=",0,"flags used for \"guibuilding\"");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditEnable=%lldLL",(long long)TGWindow::kEditEnable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisable=%lldLL",(long long)TGWindow::kEditDisable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableEvents=%lldLL",(long long)TGWindow::kEditDisableEvents).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableGrab=%lldLL",(long long)TGWindow::kEditDisableGrab).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableLayout=%lldLL",(long long)TGWindow::kEditDisableLayout).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableResize=%lldLL",(long long)TGWindow::kEditDisableResize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableHeight=%lldLL",(long long)TGWindow::kEditDisableHeight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableWidth=%lldLL",(long long)TGWindow::kEditDisableWidth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableBtnEnable=%lldLL",(long long)TGWindow::kEditDisableBtnEnable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindowcLcLEEditMode),-1,-2,1,G__FastAllocString(2048).Format("kEditDisableKeyEnable=%lldLL",(long long)TGWindow::kEditDisableKeyEnable).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPicturePool */
static void G__setup_memvarTGPicturePool(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool));
   { TGPicturePool *p; p=(TGPicturePool*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGClient),-1,-1,2,"fClient=",0,"client for which we keep icon pool");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fPath=",0,"icon search path");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_THashTable),-1,-1,2,"fPicList=",0,"hash table containing the icons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPicture */
static void G__setup_memvarTGPicture(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicture));
   { TGPicture *p; p=(TGPicture*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fName=",0,"name of picture");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fScaled=",0,"kTRUE if picture is scaled");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPic=",0,"picture pixmap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fMask=",0,"picture mask pixmap");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_PictureAttributes_t),-1,-1,2,"fAttributes=",0,"picture attributes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGGCPool */
static void G__setup_memvarTGGCPool(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool));
   { TGGCPool *p; p=(TGGCPool*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_THashTable),-1,-1,4,"fList=",0,"hash table of graphics contexts in pool");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGGC */
static void G__setup_memvarTGGC(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGC));
   { TGGC *p; p=(TGGC*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_GCValues_t),-1,-1,2,"fValues=",0,"graphics context values + mask");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fContext=",0,"graphics context handle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGUnknownWindowHandler */
static void G__setup_memvarTGUnknownWindowHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGUnknownWindowHandler));
   { TGUnknownWindowHandler *p; p=(TGUnknownWindowHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGIdleHandler */
static void G__setup_memvarTGIdleHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler));
   { TGIdleHandler *p; p=(TGIdleHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,4,"fWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSelectedPicture */
static void G__setup_memvarTGSelectedPicture(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture));
   { TGSelectedPicture *p; p=(TGSelectedPicture*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGClient),-1,-1,2,"fClient=",0,"client to which selected picture belongs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgSelectedGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDimension */
static void G__setup_memvarTGDimension(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGDimension));
   { TGDimension *p; p=(TGDimension*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fWidth)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fWidth=",0,"width");
   G__memvar_setup((void*)((long)(&p->fHeight)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fHeight=",0,"height");
   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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPosition */
static void G__setup_memvarTGPosition(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPosition));
   { TGPosition *p; p=(TGPosition*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fX=",0,"x position");
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fY=",0,"y position");
   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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLongPosition */
static void G__setup_memvarTGLongPosition(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition));
   { TGLongPosition *p; p=(TGLongPosition*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fX=",0,"x position");
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),108,0,0,-1,G__defined_typename("Long_t"),-1,1,"fY=",0,"y position");
   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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGInsets */
static void G__setup_memvarTGInsets(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInsets));
   { TGInsets *p; p=(TGInsets*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fL)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fL=",0,"left");
   G__memvar_setup((void*)((long)(&p->fR)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fR=",0,"right");
   G__memvar_setup((void*)((long)(&p->fT)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fT=",0,"top");
   G__memvar_setup((void*)((long)(&p->fB)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fB=",0,"bottom");
   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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRectangle */
static void G__setup_memvarTGRectangle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle));
   { TGRectangle *p; p=(TGRectangle*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fX=",0,"x position");
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fY=",0,"y position");
   G__memvar_setup((void*)((long)(&p->fW)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fW=",0,"width");
   G__memvar_setup((void*)((long)(&p->fH)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fH=",0,"height");
   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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFrame */
static void G__setup_memvarTGFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame));
   { TGFrame *p; p=(TGFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFramecLcLdA),-1,-2,2,"kDeleteWindowCalled=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX=",0,"frame x position");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY=",0,"frame y position");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWidth=",0,"frame width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fHeight=",0,"frame height");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMinWidth=",0,"minimal frame width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMinHeight=",0,"minimal frame height");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMaxWidth=",0,"maximal frame width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMaxHeight=",0,"maximal frame height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBorderWidth=",0,"frame border width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fOptions=",0,"frame options");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBackground=",0,"frame background color");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEventMask=",0,"currenty active event mask");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDNDState=",0,"EDNDFlags");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement),-1,-1,2,"fFE=",0,"pointer to frame element");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgInit=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgDefaultFrameBackground=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgDefaultSelectedBackground=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgWhitePixel=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgBlackPixel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgBlackGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgWhiteGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgHilightGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgShadowGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgBckgndGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Time_t"),-2,2,"fgLastClick=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgLastButton=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgDbx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgDby=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-2,2,"fgDbw=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgUserColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGCompositeFrame */
static void G__setup_memvarTGCompositeFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame));
   { TGCompositeFrame *p; p=(TGCompositeFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager),-1,-1,2,"fLayoutManager=",0,"layout manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fList=",0,"container of frame elements");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLayoutBroken=",0,"no layout manager is used");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMustCleanup=",0,"cleanup mode (see EFrameCleanup)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMapSubwindows=",0,"kTRUE - map subwindows");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-2,2,"fgDefaultHints=",0,"default hints used by AddFrame()");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLayoutHints */
static void G__setup_memvarTGLayoutHints(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints));
   { TGLayoutHints *p; p=(TGLayoutHints*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement),-1,-1,4,"fFE=",0,"back pointer to the last frame element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement),-1,-1,4,"fPrev=",0,"previous element sharing this layout_hints");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fLayoutHints=",0,"layout hints (combination of ELayoutHints)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPadtop=",0,"amount of top padding");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPadbottom=",0,"amount of bottom padding");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPadleft=",0,"amount of left padding");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPadright=",0,"amount of right padding");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFrameElement */
static void G__setup_memvarTGFrameElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement));
   { TGFrameElement *p; p=(TGFrameElement*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fFrame)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),-1,-1,1,"fFrame=",0,"frame used in layout");
   G__memvar_setup((void*)((long)(&p->fState)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fState=",0,"EFrameState defined in TGFrame.h");
   G__memvar_setup((void*)((long)(&p->fLayout)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,1,"fLayout=",0,"layout hints used in layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLayoutManager */
static void G__setup_memvarTGLayoutManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager));
   { TGLayoutManager *p; p=(TGLayoutManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fModified=",0,"kTRUE if positions of subframes changed after layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVerticalLayout */
static void G__setup_memvarTGVerticalLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout));
   { TGVerticalLayout *p; p=(TGVerticalLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),-1,-1,2,"fMain=",0,"container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fList=",0,"list of frames to arrange");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHorizontalLayout */
static void G__setup_memvarTGHorizontalLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout));
   { TGHorizontalLayout *p; p=(TGHorizontalLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRowLayout */
static void G__setup_memvarTGRowLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout));
   { TGRowLayout *p; p=(TGRowLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fSep)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSep=",0,"interval between frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGColumnLayout */
static void G__setup_memvarTGColumnLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout));
   { TGColumnLayout *p; p=(TGColumnLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMatrixLayout */
static void G__setup_memvarTGMatrixLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout));
   { TGMatrixLayout *p; p=(TGMatrixLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),-1,-1,2,"fMain=",0,"container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fList=",0,"list of frames to arrange");
   G__memvar_setup((void*)((long)(&p->fSep)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSep=",0,"interval between frames");
   G__memvar_setup((void*)((long)(&p->fHints)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fHints=",0,"layout hints (currently not used)");
   G__memvar_setup((void*)((long)(&p->fRows)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fRows=",0,"number of rows");
   G__memvar_setup((void*)((long)(&p->fColumns)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fColumns=",0,"number of columns");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTileLayout */
static void G__setup_memvarTGTileLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout));
   { TGTileLayout *p; p=(TGTileLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSep=",0,"separation between tiles");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),-1,-1,2,"fMain=",0,"container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fList=",0,"list of frames to arrange");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fModified=",0,"layout changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListLayout */
static void G__setup_memvarTGListLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout));
   { TGListLayout *p; p=(TGListLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListDetailsLayout */
static void G__setup_memvarTGListDetailsLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout));
   { TGListDetailsLayout *p; p=(TGListDetailsLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fWidth=",0,"width of listview container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGString */
static void G__setup_memvarTGString(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGString));
   { TGString *p; p=(TGString*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHotString */
static void G__setup_memvarTGHotString(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHotString));
   { TGHotString *p; p=(TGHotString*)0x1000; if (p) { }
   G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fHotChar=",0,"hot character");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHotPos=",0,"position of hot character");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fLastGC=",0,"context used during last drawing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOff1=",0,"variable used during drawing (cache)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOff2=",0,"variable used during drawing (cache)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextButton */
static void G__setup_memvarTGTextButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton));
   { TGTextButton *p; p=(TGTextButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGHotString),-1,-1,2,"fLabel=",0,"button text");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMLeft=",0,"margin left");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMRight=",0,"margin right");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMTop=",0,"margin top");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMBottom=",0,"margin bottom");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTMode=",0,"text justify mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWrapLength=",0,"wrap length");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHKeycode=",0,"hotkey");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextLayout),-1,-1,2,"fTLayout=",0,"text layout");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"font to draw text");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasOwnFont=",0,"kTRUE - font defined locally,  kFALSE - globally");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStateOn=",0,"bit to save the state across disable/enable");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPrevStateOn=",0,"bit to save previos state On/Off");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVerticalFrame */
static void G__setup_memvarTGVerticalFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame));
   { TGVerticalFrame *p; p=(TGVerticalFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHorizontalFrame */
static void G__setup_memvarTGHorizontalFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame));
   { TGHorizontalFrame *p; p=(TGHorizontalFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMainFrame */
static void G__setup_memvarTGMainFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame));
   { TGMainFrame *p; p=(TGMainFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGMainFramecLcLdA),-1,-2,2,"kDontCallClose=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fDNDTypeList=",0,"handles DND types");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fBindList=",0,"list with key bindings");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fWindowName=",0,"window name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fIconName=",0,"icon name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fIconPixmap=",0,"icon pixmap name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fClassName=",0,"WM class name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fResourceName=",0,"WM resource name");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMWMValue=",0,"MWM decoration hints");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMWMFuncs=",0,"MWM functions");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMWMInput=",0,"MWM input modes");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWMX=",0,"WM x position");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWMY=",0,"WM y position");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMWidth=",0,"WM width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMHeight=",0,"WM height");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMMinWidth=",0,"WM min width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMMinHeight=",0,"WM min height");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMMaxWidth=",0,"WM max width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMMaxHeight=",0,"WM max height");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMWidthInc=",0,"WM width increments");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fWMHeightInc=",0,"WM height increments");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EInitialState),-1,-1,2,"fWMInitState=",0,"WM initial state");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTransientFrame */
static void G__setup_memvarTGTransientFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame));
   { TGTransientFrame *p; p=(TGTransientFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,2,"fMain=",0,"window over which to popup dialog");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kCenter=%lldLL",(long long)TGTransientFrame::kCenter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kLeft=%lldLL",(long long)TGTransientFrame::kLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kRight=%lldLL",(long long)TGTransientFrame::kRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kTop=%lldLL",(long long)TGTransientFrame::kTop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kBottom=%lldLL",(long long)TGTransientFrame::kBottom).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kTopLeft=%lldLL",(long long)TGTransientFrame::kTopLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kTopRight=%lldLL",(long long)TGTransientFrame::kTopRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kBottomLeft=%lldLL",(long long)TGTransientFrame::kBottomLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFramecLcLEPlacement),-1,-2,1,G__FastAllocString(2048).Format("kBottomRight=%lldLL",(long long)TGTransientFrame::kBottomRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGGroupFrame */
static void G__setup_memvarTGGroupFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame));
   { TGGroupFrame *p; p=(TGGroupFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGString),-1,-1,2,"fText=",0,"title text");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"title fontstruct");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"title graphics context");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePos=",0,"*OPTION={GetMethod=\"GetTitlePos\";SetMethod=\"SetTitlePos\";Items=(-1=\"Left\",0=\"Center\",1=\"Right\")}*");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasOwnFont=",0,"kTRUE - font defined locally,  kFALSE - globally");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFramecLcLETitlePos),-1,-2,1,G__FastAllocString(2048).Format("kLeft=%lldLL",(long long)TGGroupFrame::kLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFramecLcLETitlePos),-1,-2,1,G__FastAllocString(2048).Format("kCenter=%lldLL",(long long)TGGroupFrame::kCenter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFramecLcLETitlePos),-1,-2,1,G__FastAllocString(2048).Format("kRight=%lldLL",(long long)TGGroupFrame::kRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHeaderFrame */
static void G__setup_memvarTGHeaderFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame));
   { TGHeaderFrame *p; p=(TGHeaderFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNColumns=",0,"number of columns");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),-1,-1,2,"fColHeader=",0,"column headers for in detailed mode");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Gui1LN_TGVFileSplitter),-1,-1,2,"fSplitHeader=",0,"column splitters");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,2,"fSplitCursor=",0,"split cursor;");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOverSplitter=",0,"Indicates if the cursor is over a splitter");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOverButton=",0,"Indicates over which button the mouse is");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastButton=",0,"Indicates the last button clicked if any");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGWidget */
static void G__setup_memvarTGWidget(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGWidget));
   { TGWidget *p; p=(TGWidget*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWidgetId=",0,"the widget id (used for event processing)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWidgetFlags=",0,"widget status flags (OR of EWidgetStatus)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window which handles widget events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fCommand=",0,"command to be executed");
   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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGIcon */
static void G__setup_memvarTGIcon(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon));
   { TGIcon *p; p=(TGIcon*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fPic=",0,"icon picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TImage),-1,-1,2,"fImage=",0,"image");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fPath=",0,"directory of image");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLabel */
static void G__setup_memvarTGLabel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel));
   { TGLabel *p; p=(TGLabel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGString),-1,-1,2,"fText=",0,"label text");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTWidth=",0,"text width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTHeight=",0,"text height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMLeft=",0,"margin left");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMRight=",0,"margin right");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMTop=",0,"margin top");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMBottom=",0,"margin bottom");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTMode=",0,"text alignment");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"f3DStyle=",0,"3D style (0 - normal, kRaisedFrame - raised, kSunkenFrame - sunken)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWrapLength=",0,"wrap length");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTFlags=",0,"text flags (see TGFont.h  ETextLayoutFlags)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTextChanged=",0,"has text changed");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"graphics context used for drawing label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-1,2,"fFont=",0,"font to draw label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextLayout),-1,-1,2,"fTLayout=",0,"text layout   ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasOwnFont=",0,"kTRUE - font defined locally,  kFALSE - globally");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDisabled=",0,"if kTRUE label looks disabled (shaded text)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGButtonGroup */
static void G__setup_memvarTGButtonGroup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup));
   { TGButtonGroup *p; p=(TGButtonGroup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fState=",0,"kTRUE if group is enabled");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fExclGroup=",0,"kTRUE if group is exclusive");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRadioExcl=",0,"kTRUE if radio buttons are exclusive");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawBorder=",0,"kTRUE if border and title are drawn");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TMap),-1,-1,2,"fMapOfButtons=",0,"map of button/id pairs in this group");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPopupMenu */
static void G__setup_memvarTGPopupMenu(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu));
   { TGPopupMenu *p; p=(TGPopupMenu*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fEntryList=",0,"list of menu entries");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry),-1,-1,2,"fCurrent=",0,"currently selected menu entry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStick=",0,"stick mode (popup menu stays sticked on screen)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasGrab=",0,"true if menu has grabbed pointer");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPoppedUp=",0,"true if menu is currently popped up");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fXl=",0,"Max width of all menu entries");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMenuWidth=",0,"width of popup menu");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMenuHeight=",0,"height of popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TTimer),-1,-1,2,"fDelay=",0,"delay before poping up cascading menu");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"normal drawing graphics context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fSelGC=",0,"graphics context for drawing selections");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fSelbackGC=",0,"graphics context for drawing selection background");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"font to draw menu entries");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fHifontStruct=",0,"font to draw highlighted entries");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,2,"fDefaultCursor=",0,"right pointing cursor");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window which handles menu events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar),-1,-1,2,"fMenuBar=",0,"menu bar (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton),-1,-1,2,"fSplitButton=",0,"split button (if any)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEntrySep=",0,"separation distance between ebtris");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgHilightFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultSelectedGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultSelectedBackgroundGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGButton */
static void G__setup_memvarTGButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton));
   { TGButton *p; p=(TGButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTWidth=",0,"button width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTHeight=",0,"button height");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,2,"fState=",0,"button state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStayDown=",0,"true if button has to stay down");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"graphics context used for drawing button");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fUserData=",0,"pointer to user data structure");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGToolTip),-1,-1,2,"fTip=",0,"tool tip associated with button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup),-1,-1,2,"fGroup=",0,"button group this button belongs to");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgHibckgndGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-2,2,"fgReleaseBtn=",0,"the last released button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPictureButton */
static void G__setup_memvarTGPictureButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton));
   { TGPictureButton *p; p=(TGPictureButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fPic=",0,"picture to be put in button");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fPicD=",0,"picture shown when button disabled");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnDisabledPic=",0,"kTRUE if disabled picture was autogenerated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGCheckButton */
static void G__setup_memvarTGCheckButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton));
   { TGCheckButton *p; p=(TGCheckButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,2,"fPrevState=",0,"previous check button state");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fOn=",0,"button ON picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fOff=",0,"button OFF picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fDisOn=",0,"button disabled and was ON picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fDisOff=",0,"button disabled and was OFF picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRadioButton */
static void G__setup_memvarTGRadioButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton));
   { TGRadioButton *p; p=(TGRadioButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,2,"fPrevState=",0,"previous radio button state");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fOn=",0,"button ON picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fOff=",0,"button OFF picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fDisOn=",0,"button disabled and was ON picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fDisOff=",0,"button disabled and was OFF picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSplitButton */
static void G__setup_memvarTGSplitButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton));
   { TGSplitButton *p; p=(TGSplitButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSplit=",0,"kTRUE if menu is in split mode");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,2,"fMBState=",0,"state for menu button in split mode");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTBWidth=",0,"width of text button");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMBWidth=",0,"width of menu button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),-1,-1,2,"fPopMenu=",0,"pointer to popup menu");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEntryId=",0,"Id of the currently active menu entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGHotString),-1,-1,2,"fMenuLabel=",0,"Label of the menu;");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,2,"fDefaultCursor=",0,"Default Cursor");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fKeyNavigate=",0,"kTRUE is keynavigation is being used");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGString),-1,-1,2,"fWidestLabel=",0,"Longest label that can be on the button");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGString),-1,-1,2,"fHeighestLabel=",0,"Heighest label that can be on the button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextBuffer */
static void G__setup_memvarTGTextBuffer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer));
   { TGTextBuffer *p; p=(TGTextBuffer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,4,"fBuffer=",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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextEntry */
static void G__setup_memvarTGTextEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry));
   { TGTextEntry *p; p=(TGTextEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEEchoMode),-1,-2,1,G__FastAllocString(2048).Format("kNormal=%lldLL",(long long)TGTextEntry::kNormal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEEchoMode),-1,-2,1,G__FastAllocString(2048).Format("kNoEcho=%lldLL",(long long)TGTextEntry::kNoEcho).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEEchoMode),-1,-2,1,G__FastAllocString(2048).Format("kPassword=%lldLL",(long long)TGTextEntry::kPassword).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEInsertMode),-1,-2,1,G__FastAllocString(2048).Format("kInsert=%lldLL",(long long)TGTextEntry::kInsert).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEInsertMode),-1,-2,1,G__FastAllocString(2048).Format("kReplace=%lldLL",(long long)TGTextEntry::kReplace).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer),-1,-1,2,"fText=",0,"text buffer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStartX=",0,"selection begin in pixels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEndX=",0,"selection end in pixels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStartIX=",0,"selection begin in characters");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEndIX=",0,"selection end in characters");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSelectionOn=",0,"selection status (on/off)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOffset=",0,"start position of text (in pixels)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCursorX=",0,"cursor position in pixels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCursorIX=",0,"cursor position in characters");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCursorOn=",0,"cursor status (on/off)");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"text font");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-1,2,"fNormGC=",0,"normal drawing context");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-1,2,"fSelGC=",0,"selected text drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fSelbackGC=",0,"selected background drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-1,2,"fClipboard=",0,"clipboard property");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TBlinkTimer),-1,-1,2,"fCurBlink=",0,"cursor blink timer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGToolTip),-1,-1,2,"fTip=",0,"associated tooltip");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxLen=",0,"maximum length of text");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEdited=",0,"kFALSE, if the line edit's contents have not been changed since the construction");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFrameDrawn=",0,"kTRUE draw itself inside a two-pixel frame, kFALSE draw without any frame");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEEchoMode),-1,-1,2,"fEchoMode=",0,"*OPTION={GetMethod=\"GetEchoMode\";SetMethod=\"SetEchoMode\";Items=(kNormal=\"Normal\",kNoEcho=\"No Echo\",kPassword=\"Password\")}*");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEInsertMode),-1,-1,2,"fInsertMode=",0,"*OPTION={GetMethod=\"GetInsertMode\";SetMethod=\"SetInsertMode\";Items=(kInsert=\"Insert\",kReplace=\"Replace\")}*");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,2,"fAlignment=",0,"*OPTION={GetMethod=\"GetAlignment\";SetMethod=\"SetAlignment\";Items=(kTextLeft=\"Left\",kTextCenterX=\"Center\",kTextRight=\"Right\")}*");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasOwnFont=",0,"kTRUE - font defined locally,  kFALSE - globally");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDefWidth=",0,"default width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDefHeight=",0,"default height");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-2,2,"fgClipboardText=",0,"application clipboard text");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultSelectedGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultSelectedBackgroundGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMsgBox */
static void G__setup_memvarTGMsgBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox));
   { TGMsgBox *p; p=(TGMsgBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fYes=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fNo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fOK=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fApply=",0,"buttons in dialog box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fRetry=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fIgnore=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fCancel=",0,"buttons in dialog box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fClose=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fYesAll=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fNoAll=",0,"buttons in dialog box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fNewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fAppend=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fDismiss=",0,"buttons in dialog box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGIcon),-1,-1,2,"fIcon=",0,"icon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),-1,-1,2,"fButtonFrame=",0,"frame containing buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame),-1,-1,2,"fIconFrame=",0,"frame containing icon and text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame),-1,-1,2,"fLabelFrame=",0,"frame containing text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL4=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL5=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fMsgList=",0,"text (list of TGLabels)");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRetCode=",0,"address to store return code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMenuBar */
static void G__setup_memvarTGMenuBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar));
   { TGMenuBar *p; p=(TGMenuBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle),-1,-1,2,"fCurrent=",0,"current menu title");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fTitles=",0,"list of menu titles");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,2,"fDefaultCursor=",0,"right pointing cursor");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStick=",0,"stick mode (popup menu stays sticked on screen)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fTrash=",0,"garbage");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fKeyNavigate=",0,"kTRUE if arrow key navigation is on");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),-1,-1,2,"fMenuMore=",0,"extra >> menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fMenuBarMoreLayout=",0,"layout of the extra menu");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fWithExt=",0,"indicates whether the >> menu is shown or not");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fOutLayouts=",0,"keeps trace of layouts of hidden menus");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fNeededSpace=",0,"keeps trace of space needed for hidden menus");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMenuTitle */
static void G__setup_memvarTGMenuTitle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle));
   { TGMenuTitle *p; p=(TGMenuTitle*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),-1,-1,2,"fMenu=",0,"attached popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGHotString),-1,-1,2,"fLabel=",0,"menu title");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitleId=",0,"id of selected menu item");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fTitleData=",0,"user data associated with selected item");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fState=",0,"menu title state (active/not active)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHkeycode=",0,"hot key code");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"font");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fTextColor=",0,"text color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fSelGC=",0,"normal and selection graphics contexts");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultSelectedGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMenuEntry */
static void G__setup_memvarTGMenuEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry));
   { TGMenuEntry *p; p=(TGMenuEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEntryId=",0,"the entry id (used for event processing)");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fUserData=",0,"pointer to user data structure");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryType),-1,-1,2,"fType=",0,"type of entry");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatus=",0,"entry status (OR of EMenuEntryState)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEy=",0,"position of entry");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEw=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEh=",0,"width and height of entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGHotString),-1,-1,2,"fLabel=",0,"menu entry label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGString),-1,-1,2,"fShortcut=",0,"menu entry shortcut");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,2,"fPic=",0,"menu entry icon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu),-1,-1,2,"fPopup=",0,"pointer to popup menu (in case of cascading menus)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGShutterItem */
static void G__setup_memvarTGShutterItem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem));
   { TGShutterItem *p; p=(TGShutterItem*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fButton=",0,"shutter item button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGCanvas),-1,-1,2,"fCanvas=",0,"canvas of shutter item");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFrame),-1,-1,2,"fContainer=",0,"container in canvas containing shutter items");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints),-1,-1,2,"fL2=",0,"positioning hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGShutter */
static void G__setup_memvarTGShutter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter));
   { TGShutter *p; p=(TGShutter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TTimer),-1,-1,2,"fTimer=",0,"Timer for animation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),-1,-1,2,"fSelectedItem=",0,"Item currently open");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem),-1,-1,2,"fClosingItem=",0,"Item closing down");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fTrash=",0,"Items that need to be cleaned up");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHeightIncrement=",0,"Height delta");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fClosingHeight=",0,"Closing items current height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fClosingHadScrollbar=",0,"Closing item had a scroll bar");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDefWidth=",0,"Default width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDefHeight=",0,"Default height");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHorizontal3DLine */
static void G__setup_memvarTGHorizontal3DLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine));
   { TGHorizontal3DLine *p; p=(TGHorizontal3DLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVertical3DLine */
static void G__setup_memvarTGVertical3DLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine));
   { TGVertical3DLine *p; p=(TGVertical3DLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGProgressBar */
static void G__setup_memvarTGProgressBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar));
   { TGProgressBar *p; p=(TGProgressBar*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEBarType),-1,-2,1,G__FastAllocString(2048).Format("kStandard=%lldLL",(long long)TGProgressBar::kStandard).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEBarType),-1,-2,1,G__FastAllocString(2048).Format("kFancy=%lldLL",(long long)TGProgressBar::kFancy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEFillType),-1,-2,1,G__FastAllocString(2048).Format("kSolidFill=%lldLL",(long long)TGProgressBar::kSolidFill).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEFillType),-1,-2,1,G__FastAllocString(2048).Format("kBlockFill=%lldLL",(long long)TGProgressBar::kBlockFill).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kProgressBarStandardWidth=%lldLL",(long long)TGProgressBar::kProgressBarStandardWidth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kProgressBarTextWidth=%lldLL",(long long)TGProgressBar::kProgressBarTextWidth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBlockSize=%lldLL",(long long)TGProgressBar::kBlockSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBlockSpace=%lldLL",(long long)TGProgressBar::kBlockSpace).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMin=",0,"logical minimum value (default 0)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMax=",0,"logical maximum value (default 100)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPos=",0,"logical position [fMin,fMax]");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPosPix=",0,"position of progress bar in pixel coordinates");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBarWidth=",0,"progress bar width");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEFillType),-1,-1,2,"fFillType=",0,"*OPTION={GetMethod=\"GetFillType\";SetMethod=\"SetFillType\";Items=(kSolidFill=Solid\",kBlockFill=\"Block\")}*");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEBarType),-1,-1,2,"fBarType=",0,"*OPTION={GetMethod=\"GetBarType\";SetMethod=\"SetBarType\";Items=(kStandard=\"Standard\",kFancy=\"Fancy\")}*");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TString),-1,-1,2,"fFormat=",0,"format used to show position not in percent");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowPos=",0,"show position value (default false)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPercent=",0,"show position in percent (default true)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawBar=",0,"if true draw only bar in DoRedraw()");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-1,2,"fBarColorGC=",0,"progress bar drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"text drawing graphics context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"font used to draw position text");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHProgressBar */
static void G__setup_memvarTGHProgressBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar));
   { TGHProgressBar *p; p=(TGHProgressBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVProgressBar */
static void G__setup_memvarTGVProgressBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar));
   { TGVProgressBar *p; p=(TGVProgressBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVButtonGroup */
static void G__setup_memvarTGVButtonGroup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup));
   { TGVButtonGroup *p; p=(TGVButtonGroup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHButtonGroup */
static void G__setup_memvarTGHButtonGroup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup));
   { TGHButtonGroup *p; p=(TGHButtonGroup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGNumberFormat */
static void G__setup_memvarTGNumberFormat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat));
   { TGNumberFormat *p; p=(TGNumberFormat*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESInteger=%lldLL",(long long)TGNumberFormat::kNESInteger).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESRealOne=%lldLL",(long long)TGNumberFormat::kNESRealOne).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESRealTwo=%lldLL",(long long)TGNumberFormat::kNESRealTwo).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESRealThree=%lldLL",(long long)TGNumberFormat::kNESRealThree).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESRealFour=%lldLL",(long long)TGNumberFormat::kNESRealFour).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESReal=%lldLL",(long long)TGNumberFormat::kNESReal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESDegree=%lldLL",(long long)TGNumberFormat::kNESDegree).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESMinSec=%lldLL",(long long)TGNumberFormat::kNESMinSec).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESHourMin=%lldLL",(long long)TGNumberFormat::kNESHourMin).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESHourMinSec=%lldLL",(long long)TGNumberFormat::kNESHourMinSec).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESDayMYear=%lldLL",(long long)TGNumberFormat::kNESDayMYear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESMDayYear=%lldLL",(long long)TGNumberFormat::kNESMDayYear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kNESHex=%lldLL",(long long)TGNumberFormat::kNESHex).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute),-1,-2,1,G__FastAllocString(2048).Format("kNEAAnyNumber=%lldLL",(long long)TGNumberFormat::kNEAAnyNumber).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute),-1,-2,1,G__FastAllocString(2048).Format("kNEANonNegative=%lldLL",(long long)TGNumberFormat::kNEANonNegative).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute),-1,-2,1,G__FastAllocString(2048).Format("kNEAPositive=%lldLL",(long long)TGNumberFormat::kNEAPositive).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit),-1,-2,1,G__FastAllocString(2048).Format("kNELNoLimits=%lldLL",(long long)TGNumberFormat::kNELNoLimits).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit),-1,-2,1,G__FastAllocString(2048).Format("kNELLimitMin=%lldLL",(long long)TGNumberFormat::kNELLimitMin).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit),-1,-2,1,G__FastAllocString(2048).Format("kNELLimitMax=%lldLL",(long long)TGNumberFormat::kNELLimitMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit),-1,-2,1,G__FastAllocString(2048).Format("kNELLimitMinMax=%lldLL",(long long)TGNumberFormat::kNELLimitMinMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStepSize),-1,-2,1,G__FastAllocString(2048).Format("kNSSSmall=%lldLL",(long long)TGNumberFormat::kNSSSmall).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStepSize),-1,-2,1,G__FastAllocString(2048).Format("kNSSMedium=%lldLL",(long long)TGNumberFormat::kNSSMedium).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStepSize),-1,-2,1,G__FastAllocString(2048).Format("kNSSLarge=%lldLL",(long long)TGNumberFormat::kNSSLarge).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStepSize),-1,-2,1,G__FastAllocString(2048).Format("kNSSHuge=%lldLL",(long long)TGNumberFormat::kNSSHuge).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__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGNumberEntryField */
static void G__setup_memvarTGNumberEntryField(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField));
   { TGNumberEntryField *p; p=(TGNumberEntryField*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNeedsVerification=",0,"Needs verification of input");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-1,2,"fNumStyle=",0,"Number style");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute),-1,-1,2,"fNumAttr=",0,"Number attribute");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit),-1,-1,2,"fNumLimits=",0,"Limit attributes");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNumMin=",0,"Lower limit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNumMax=",0,"Upper limit");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStepLog=",0,"Logarithmic steps for increase?");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGNumberEntry */
static void G__setup_memvarTGNumberEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry));
   { TGNumberEntry *p; p=(TGNumberEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),-1,-1,4,"fNumStyle=",0,"*OPTION={GetMethod=\"GetNumStyle\";SetMethod=\"SetNumStyle\";Items=(0=\"Int\",5=\"Real\",6=\"Degree\",9=\"Hour:Min:Sec\",10=\"Day/Month/Year\",12=\"Hex\")}*");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute),-1,-1,4,"fNumAttr=",0,"*OPTION={GetMethod=\"GetNumAttr\";SetMethod=\"SetNumAttr\";Items=(0=\"&AnyNumber\",1=\"&Non negative\",2=\"&Positive\")}*");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit),-1,-1,4,"fNumLimits=",0,"*OPTION={GetMethod=\"GetNumLimits\";SetMethod=\"SetNumLimits\";Items=(0=\"&No Limits\",1=\"Limit M&in\",2=\"Limit M&ax\",2=\"Min &and Max\")}*");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,4,"fPicUp=",0,"Up arrow");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui1LN_TGPicture),-1,-1,4,"fPicDown=",0,"Down arrow");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField),-1,-1,2,"fNumericEntry=",0,"Number text entry field");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fButtonUp=",0,"Button for increasing value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGButton),-1,-1,2,"fButtonDown=",0,"Button for decreasing value");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fButtonToNum=",0,"Send button messages to parent rather than number entry field");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGNumberEntryLayout */
static void G__setup_memvarTGNumberEntryLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout));
   { TGNumberEntryLayout *p; p=(TGNumberEntryLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry),-1,-1,2,"fBox=",0,"pointer to numeric control box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTableLayoutHints */
static void G__setup_memvarTGTableLayoutHints(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints));
   { TGTableLayoutHints *p; p=(TGTableLayoutHints*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fAttachLeft=",0,"Column/row division number on which");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fAttachRight=",0,"to attach the frame.  Starts at 0");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fAttachTop=",0,"and goes to # columns / # rows");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fAttachBottom=",0,"respectively");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTableLayout */
static void G__setup_memvarTGTableLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout));
   { TGTableLayout *p; p=(TGTableLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutcLcLTableData_t),-1,-1,2,"fRow=",0,"info about each row");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutcLcLTableData_t),-1,-1,2,"fCol=",0,"info about each column");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame),-1,-1,2,"fMain=",0,"container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TList),-1,-1,2,"fList=",0,"list of frames to arrange");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHomogeneous=",0,"all cols/rows same size");
   G__memvar_setup((void*)((long)(&p->fSep)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSep=",0,"interval between frames");
   G__memvar_setup((void*)((long)(&p->fHints)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fHints=",0,"layout hints (currently not used)");
   G__memvar_setup((void*)((long)(&p->fNrows)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fNrows=",0,"number of rows");
   G__memvar_setup((void*)((long)(&p->fNcols)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fNcols=",0,"number of columns");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGInputDialog */
static void G__setup_memvarTGInputDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog));
   { TGInputDialog *p; p=(TGInputDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGLabel),-1,-1,4,"fLabel=",0,"text entry label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry),-1,-1,4,"fTE=",0,"text entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),-1,-1,4,"fOk=",0,"ok button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton),-1,-1,4,"fCancel=",0,"cancel button");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fRetStr=",0,"address to store return string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFrameElementPack */
static void G__setup_memvarTGFrameElementPack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack));
   { TGFrameElementPack *p; p=(TGFrameElementPack*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fWeight)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fWeight=",0,"relative weight");
   G__memvar_setup((void*)((long)(&p->fSplitFE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack),-1,-1,1,"fSplitFE=",0,"! cached varaible for optimisation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPack */
static void G__setup_memvarTGPack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack));
   { TGPack *p; p=(TGPack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fVertical=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseSplitters=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSplitterLen=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDragOverflow=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWeightSum=",0,"total sum of sub  frame weights");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNVisible=",0,"number of visible frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Gui1() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTGClient(void) {
   /* TGClient */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGClient));
   G__memfunc_setup("TGClient",762,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGClient), -1, 0, 1, 1, 2, 0, "u 'TGClient' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGClient), -1, 1, 1, 1, 2, 0, "u 'TGClient' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("ProcessOneEvent",1539,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessIdleEvent",1631,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGClient",762,G__G__Gui1_115_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGClient), -1, 0, 1, 1, 1, 0, "C - - 10 '0' dpyName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRoot",708,G__G__Gui1_115_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultRoot",1417,G__G__Gui1_115_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRoot",720,G__G__Gui1_115_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 '0' root", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowById",1280,G__G__Gui1_115_0_10, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 1, 1, 1, 8, "k - 'Window_t' 0 - sw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowByName",1492,G__G__Gui1_115_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDisplayWidth",1526,G__G__Gui1_115_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDisplayHeight",1615,G__G__Gui1_115_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEditable",982,G__G__Gui1_115_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEditDisabled",1370,G__G__Gui1_115_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditDisabled",1482,G__G__Gui1_115_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontByName",1267,G__G__Gui1_115_0_17, 107, -1, G__defined_typename("FontStruct_t"), 0, 2, 1, 1, 8, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' fixedDefault", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColorByName",1371,G__G__Gui1_115_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"C - - 10 - name k - 'Pixel_t' 1 - pixel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHilite",895,G__G__Gui1_115_0_19, 107, -1, G__defined_typename("Pixel_t"), 0, 1, 1, 1, 8, "k - 'Pixel_t' 0 - base_color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShadow",902,G__G__Gui1_115_0_20, 107, -1, G__defined_typename("Pixel_t"), 0, 1, 1, 1, 8, "k - 'Pixel_t' 0 - base_color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeColor",897,G__G__Gui1_115_0_21, 121, -1, -1, 0, 1, 1, 1, 8, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceRedraw",1108,G__G__Gui1_115_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NeedRedraw",993,G__G__Gui1_115_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 0 - w g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterWindow",1469,G__G__Gui1_115_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnregisterWindow",1696,G__G__Gui1_115_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterPopup",1369,G__G__Gui1_115_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnregisterPopup",1596,G__G__Gui1_115_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddUnknownWindowHandler",2351,G__G__Gui1_115_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGUnknownWindowHandler' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveUnknownWindowHandler",2708,G__G__Gui1_115_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGUnknownWindowHandler' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddIdleHandler",1349,G__G__Gui1_115_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGIdleHandler' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveIdleHandler",1706,G__G__Gui1_115_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGIdleHandler' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleInput",1116,G__G__Gui1_115_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessLine",1127,G__G__Gui1_115_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TString' - 0 - cmd l - 'Long_t' 0 - msg "
"l - 'Long_t' 0 - parm1 l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WaitFor",700,G__G__Gui1_115_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WaitForUnmap",1213,G__G__Gui1_115_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetWaitFor",1215,G__G__Gui1_115_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaitForEvent",1502,G__G__Gui1_115_0_37, 105, G__get_linked_tagnum(&G__G__Gui1LN_EGEventType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaitForWindow",1620,G__G__Gui1_115_0_38, 107, -1, G__defined_typename("Window_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessEventsFor",1659,G__G__Gui1_115_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleEvent",1102,G__G__Gui1_115_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMaskEvent",1498,G__G__Gui1_115_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'Event_t' - 0 - event k - 'Window_t' 0 - wid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisteredWindow",1670,G__G__Gui1_115_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Window_t' 0 - w", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("ProcessedEvent",1450,G__G__Gui1_115_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'Event_t' - 0 - event k - 'Window_t' 0 - wid", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("GetResourcePool",1538,G__G__Gui1_115_0_44, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGResourcePool), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicturePool",1430,G__G__Gui1_115_0_45, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_115_0_46, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 1, 1, 1, 1, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_115_0_47, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 3, 1, 1, 1, 
"C - - 10 - name h - 'UInt_t' 0 - new_width "
"h - 'UInt_t' 0 - new_height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreePicture",1118,G__G__Gui1_115_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGCPool",836,G__G__Gui1_115_0_49, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGC",426,G__G__Gui1_115_0_50, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 2, 1, 1, 0, 
"U 'GCValues_t' - 0 - values g - 'Bool_t' 0 'kFALSE' rw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeGC",524,G__G__Gui1_115_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGGC' - 10 - gc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeGC",524,G__G__Gui1_115_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'GContext_t' 0 - gc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontPool",1105,G__G__Gui1_115_0_53, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFontPool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui1_115_0_54, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFont), -1, 0, 2, 1, 1, 0, 
"C - - 10 - font g - 'Bool_t' 0 'kTRUE' fixedDefault", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui1_115_0_55, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFont), -1, 0, 1, 1, 1, 0, "U 'TGFont' - 10 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeFont",793,G__G__Gui1_115_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFont' - 10 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultColormap",1826,G__G__Gui1_115_0_57, 107, -1, G__defined_typename("Colormap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMimeTypeList",1510,G__G__Gui1_115_0_58, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGMimeTypes), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfWindows",1628,G__G__Gui1_115_0_59, 85, G__get_linked_tagnum(&G__G__Gui1LN_THashList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfPopups",1528,G__G__Gui1_115_0_60, 85, G__get_linked_tagnum(&G__G__Gui1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_115_0_61, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGClient::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_115_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGClient::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_115_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGClient::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_115_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGClient::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_115_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_115_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGClient::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_115_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGClient::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_115_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGClient::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_115_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGClient::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGClient", 888, G__G__Gui1_115_0_73, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGObject(void) {
   /* TGObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGObject));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGObject), -1, 1, 1, 1, 2, 0, "u 'TGObject' - 11 - tgo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGObject",754,G__G__Gui1_116_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGObject",754,G__G__Gui1_116_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGObject), -1, 0, 1, 1, 1, 0, "u 'TGObject' - 11 - tgo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetId",461,G__G__Gui1_116_0_4, 107, -1, G__defined_typename("Handle_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClient",895,G__G__Gui1_116_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGClient), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("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("SaveAs",579,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"\"' filename C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_116_0_9, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_116_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_116_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_116_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_116_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_116_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_116_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_116_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_116_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGObject::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGObject", 880, G__G__Gui1_116_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGWindow(void) {
   /* TGWindow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGWindow));
   G__memfunc_setup("TGWindow",787,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 1, 1, 2, 0, "k - 'Window_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGWindow",787,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 1, 1, 2, 0, "u 'TGWindow' - 11 - tgw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 1, 1, 1, 2, 0, "u 'TGWindow' - 11 - tgw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGWindow",787,G__G__Gui1_132_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 11, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '0' x "
"i - 'Int_t' 0 '0' y h - 'UInt_t' 0 '0' w "
"h - 'UInt_t' 0 '0' h h - 'UInt_t' 0 '0' border "
"i - 'Int_t' 0 '0' depth h - 'UInt_t' 0 '0' clss "
"Y - - 0 '0' visual U 'SetWindowAttributes_t' - 0 '0' attr "
"h - 'UInt_t' 0 '0' wtype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGWindow",787,G__G__Gui1_132_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 3, 1, 1, 0, 
"U 'TGClient' - 0 - c k - 'Window_t' 0 - id "
"U 'TGWindow' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Gui1_132_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMainFrame",1168,G__G__Gui1_132_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapWindow",918,G__G__Gui1_132_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapSubwindows",1363,G__G__Gui1_132_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapRaised",886,G__G__Gui1_132_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnmapWindow",1145,G__G__Gui1_132_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyWindow",1378,G__G__Gui1_132_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroySubwindows",1823,G__G__Gui1_132_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RaiseWindow",1132,G__G__Gui1_132_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerWindow",1153,G__G__Gui1_132_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IconifyWindow",1353,G__G__Gui1_132_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReparentWindow",1465,G__G__Gui1_132_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p i - 'Int_t' 0 '0' x "
"i - 'Int_t' 0 '0' y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RequestFocus",1257,G__G__Gui1_132_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBackgroundColor",1835,G__G__Gui1_132_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBackgroundPixmap",1947,G__G__Gui1_132_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - pixmap", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleExpose",1216,G__G__Gui1_132_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleEvent",1102,G__G__Gui1_132_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleIdleEvent",1484,G__G__Gui1_132_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGIdleHandler' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Move",407,G__G__Gui1_132_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,G__G__Gui1_132_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveResize",1033,G__G__Gui1_132_0_28, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMapped",787,G__G__Gui1_132_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEditable",982,G__G__Gui1_132_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEditDisabled",1470,G__G__Gui1_132_0_31, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditDisabled",1482,G__G__Gui1_132_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 'kEditDisable' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditable",1094,G__G__Gui1_132_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MustCleanup",1137,G__G__Gui1_132_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("SetWindowName",1317,G__G__Gui1_132_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' name", (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("SetName",685,G__G__Gui1_132_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMapSubwindows",1663,G__G__Gui1_132_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMapSubwindows",1551,G__G__Gui1_132_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCounter",1024,G__G__Gui1_132_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TGWindow::GetCounter) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui1_132_0_42, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGWindow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_132_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGWindow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_132_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGWindow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_132_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGWindow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_132_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__Gui1_132_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGWindow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_132_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGWindow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_132_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGWindow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_132_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGWindow::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGWindow", 913, G__G__Gui1_132_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPicturePool(void) {
   /* TGPicturePool */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool));
   G__memfunc_setup("TGPicturePool",1297,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool), -1, 0, 1, 1, 2, 0, "u 'TGPicturePool' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool), -1, 1, 1, 1, 2, 0, "u 'TGPicturePool' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPicturePool",1297,G__G__Gui1_134_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPicturePool), -1, 0, 2, 1, 1, 0, 
"U 'TGClient' - 10 - client C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPath",685,G__G__Gui1_134_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_134_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 1, 1, 1, 1, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_134_0_6, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 2, 1, 1, 1, 
"C - - 10 - name C - - 2 - xpm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_134_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 3, 1, 1, 1, 
"C - - 10 - name h - 'UInt_t' 0 - new_width "
"h - 'UInt_t' 0 - new_height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_134_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 3, 1, 1, 1, 
"C - - 10 - name k - 'Pixmap_t' 0 - pxmap "
"k - 'Pixmap_t' 0 '0' mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreePicture",1118,G__G__Gui1_134_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (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__Gui1_134_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPicturePool::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_134_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPicturePool::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_134_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPicturePool::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_134_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPicturePool::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_134_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__Gui1_134_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPicturePool::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_134_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPicturePool::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_134_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPicturePool::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_134_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPicturePool::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGPicturePool", 1423, G__G__Gui1_134_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPicture(void) {
   /* TGPicture */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPicture));
   G__memfunc_setup("TGPicture",887,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 2, 1, 2, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' scaled", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPicture",887,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 3, 1, 2, 0, 
"C - - 10 - name k - 'Pixmap_t' 0 - pxmap "
"k - 'Pixmap_t' 0 '0' mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 '\"\"' -", (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("GetWidth",800,G__G__Gui1_135_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeight",889,G__G__Gui1_135_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_135_0_7, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMask",684,G__G__Gui1_135_0_8, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsScaled",776,G__G__Gui1_135_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("HashName",773,G__G__Gui1_135_0_11, 67, -1, -1, 0, 3, 3, 1, 1, 
"C - - 10 - name i - 'Int_t' 0 - width "
"i - 'Int_t' 0 - height", (char*)NULL, (void*) G__func2void( (const char* (*)(const char*, Int_t, Int_t))(&TGPicture::HashName) ), 0);
   G__memfunc_setup("Draw",398,G__G__Gui1_135_0_12, 121, -1, -1, 0, 4, 1, 1, 8, 
"k - 'Handle_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (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("Class",502,G__G__Gui1_135_0_14, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPicture::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_135_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPicture::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_135_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPicture::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_135_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPicture::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_135_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__Gui1_135_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPicture::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_135_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPicture::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_135_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPicture::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_135_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPicture::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGPicture", 887, G__G__Gui1_135_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 1, 1, 1, 0, "u 'TGPicture' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGPicture", 1013, G__G__Gui1_135_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__Gui1_135_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 1, 1, 1, 1, 0, "u 'TGPicture' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGGCPool(void) {
   /* TGGCPool */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool));
   G__memfunc_setup("ForceFreeGC",1019,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGGC' - 10 - gc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchGC",631,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"U 'TGGC' - 10 - gc U 'GCValues_t' - 0 - values", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateGC",749,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TGGC' - 0 - gc U 'GCValues_t' - 0 - values", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGGCPool",703,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool), -1, 0, 1, 1, 2, 0, "u 'TGGCPool' - 11 - gp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool), -1, 1, 1, 1, 2, 0, "u 'TGGCPool' - 11 - gp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGGCPool",703,G__G__Gui1_136_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGCPool), -1, 0, 1, 1, 1, 0, "U 'TGClient' - 0 - client", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGC",426,G__G__Gui1_136_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 2, 1, 1, 0, 
"U 'GCValues_t' - 0 - values g - 'Bool_t' 0 'kFALSE' rw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGC",426,G__G__Gui1_136_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 1, 1, 1, 0, "k - 'GContext_t' 0 - gct", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeGC",524,G__G__Gui1_136_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGGC' - 10 - gc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeGC",524,G__G__Gui1_136_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'GContext_t' 0 - gc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindGC",523,G__G__Gui1_136_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 1, 1, 1, 0, "U 'TGGC' - 10 - gc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindGC",523,G__G__Gui1_136_0_12, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 1, 1, 1, 0, "k - 'GContext_t' 0 - gc", (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__Gui1_136_0_14, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGGCPool::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_136_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGCPool::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_136_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGGCPool::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_136_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGGCPool::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_136_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__Gui1_136_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGCPool::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_136_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGCPool::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_136_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGCPool::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_136_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGCPool::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGGCPool", 829, G__G__Gui1_136_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGGC(void) {
   /* TGGC */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGC));
   G__memfunc_setup("TGGC",293,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 2, 1, 2, 0, 
"U 'GCValues_t' - 0 - values g - 'Bool_t' 0 - calledByGCPool", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateValues",1235,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'GCValues_t' - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaskString",1315,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 2, 8, "", "used in SavePrimitive()", (void*) NULL, 0);
   G__memfunc_setup("TGGC",293,G__G__Gui1_137_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 1, 1, 1, 0, "U 'GCValues_t' - 0 '0' values", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGGC",293,G__G__Gui1_137_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 0, 1, 1, 1, 0, "u 'TGGC' - 11 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Gui1_137_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 1, 1, 1, 0, "u 'TGGC' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGC",426,G__G__Gui1_137_0_7, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Gui1_137_0_8, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttributes",1363,G__G__Gui1_137_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'GCValues_t' - 0 - values", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFunction",1138,G__G__Gui1_137_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EGraphicsFunction' - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlaneMask",1192,G__G__Gui1_137_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetForeground",1351,G__G__Gui1_137_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackground",1324,G__G__Gui1_137_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineWidth",1204,G__G__Gui1_137_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineStyle",1221,G__G__Gui1_137_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCapStyle",1105,G__G__Gui1_137_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetJoinStyle",1229,G__G__Gui1_137_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillStyle",1220,G__G__Gui1_137_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillRule",1099,G__G__Gui1_137_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTile",698,G__G__Gui1_137_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStipple",1037,G__G__Gui1_137_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTileStipXOrigin",1818,G__G__Gui1_137_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTileStipYOrigin",1819,G__G__Gui1_137_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFont",707,G__G__Gui1_137_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'FontH_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubwindowMode",1651,G__G__Gui1_137_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGraphicsExposures",2091,G__G__Gui1_137_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipXOrigin",1396,G__G__Gui1_137_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipYOrigin",1397,G__G__Gui1_137_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipMask",1088,G__G__Gui1_137_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDashOffset",1299,G__G__Gui1_137_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDashList",1096,G__G__Gui1_137_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - v i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetArcMode",967,G__G__Gui1_137_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttributes",1351,G__G__Gui1_137_0_33, 85, G__get_linked_tagnum(&G__G__Gui1LN_GCValues_t), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMask",684,G__G__Gui1_137_0_34, 104, -1, G__defined_typename("Mask_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunction",1126,G__G__Gui1_137_0_35, 105, G__get_linked_tagnum(&G__G__Gui1LN_EGraphicsFunction), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlaneMask",1180,G__G__Gui1_137_0_36, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetForeground",1339,G__G__Gui1_137_0_37, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBackground",1312,G__G__Gui1_137_0_38, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineWidth",1192,G__G__Gui1_137_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineStyle",1209,G__G__Gui1_137_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTile",686,G__G__Gui1_137_0_41, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStipple",1025,G__G__Gui1_137_0_42, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTileStipXOrigin",1806,G__G__Gui1_137_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTileStipYOrigin",1807,G__G__Gui1_137_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubwindowMode",1639,G__G__Gui1_137_0_45, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui1_137_0_46, 107, -1, G__defined_typename("FontH_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraphicsExposures",2079,G__G__Gui1_137_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipXOrigin",1384,G__G__Gui1_137_0_48, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipYOrigin",1385,G__G__Gui1_137_0_49, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipMask",1076,G__G__Gui1_137_0_50, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCapStyle",1093,G__G__Gui1_137_0_51, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetJoinStyle",1217,G__G__Gui1_137_0_52, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFillStyle",1208,G__G__Gui1_137_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFillRule",1087,G__G__Gui1_137_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDashOffset",1287,G__G__Gui1_137_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDashLen",959,G__G__Gui1_137_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDashes",888,G__G__Gui1_137_0_57, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArcMode",955,G__G__Gui1_137_0_58, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("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("Class",502,G__G__Gui1_137_0_61, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGGC::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_137_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGC::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_137_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGGC::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_137_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGGC::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_137_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_137_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGC::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_137_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGC::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_137_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGC::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_137_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGC::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGGC", 419, G__G__Gui1_137_0_73, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGUnknownWindowHandler(void) {
   /* TGUnknownWindowHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGUnknownWindowHandler));
   G__memfunc_setup("HandleEvent",1102,G__G__Gui1_141_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Gui1_141_0_3, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGUnknownWindowHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_141_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGUnknownWindowHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_141_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGUnknownWindowHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_141_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGUnknownWindowHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_141_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_141_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGUnknownWindowHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_141_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGUnknownWindowHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_141_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGUnknownWindowHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_141_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGUnknownWindowHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGUnknownWindowHandler", 2367, G__G__Gui1_141_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__Gui1_141_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGUnknownWindowHandler), -1, 1, 1, 1, 1, 0, "u 'TGUnknownWindowHandler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGIdleHandler(void) {
   /* TGIdleHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler));
   G__memfunc_setup("TGIdleHandler",1239,G__G__Gui1_142_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleEvent",1102,G__G__Gui1_142_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_142_0_3, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGIdleHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_142_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIdleHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_142_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGIdleHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_142_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGIdleHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_142_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_142_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIdleHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_142_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGIdleHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_142_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIdleHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_142_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGIdleHandler::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGIdleHandler", 1239, G__G__Gui1_142_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler), -1, 0, 1, 1, 1, 0, "u 'TGIdleHandler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGIdleHandler", 1365, G__G__Gui1_142_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_142_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGIdleHandler), -1, 1, 1, 1, 1, 0, "u 'TGIdleHandler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSelectedPicture(void) {
   /* TGSelectedPicture */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture));
   G__memfunc_setup("GetSelectedGC",1235,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGSelectedPicture",1696,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture), -1, 0, 1, 1, 2, 0, "u 'TGSelectedPicture' - 11 - gp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture), -1, 1, 1, 1, 2, 0, "u 'TGSelectedPicture' - 11 - gp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGSelectedPicture",1696,G__G__Gui1_160_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGSelectedPicture), -1, 0, 2, 1, 1, 0, 
"U 'TGClient' - 10 - client U 'TGPicture' - 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_160_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSelectedPicture::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_160_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSelectedPicture::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_160_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSelectedPicture::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_160_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSelectedPicture::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_160_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_160_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSelectedPicture::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_160_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSelectedPicture::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_160_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSelectedPicture::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_160_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSelectedPicture::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSelectedPicture", 1822, G__G__Gui1_160_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDimension(void) {
   /* TGDimension */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGDimension));
   G__memfunc_setup("TGDimension",1089,G__G__Gui1_161_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGDimension",1089,G__G__Gui1_161_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGDimension",1089,G__G__Gui1_161_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 1, 1, 1, 0, "u 'TGDimension' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Gui1_161_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGDimension' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Gui1_161_0_5, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 1, 1, 1, 8, "u 'TGDimension' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Gui1_161_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 1, 1, 1, 8, "u 'TGDimension' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_161_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDimension::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_161_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDimension::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_161_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDimension::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_161_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDimension::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_161_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_161_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui1_161_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui1_161_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_161_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDimension::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_161_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDimension::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_161_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDimension::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_161_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDimension::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDimension", 1215, G__G__Gui1_161_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_161_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 1, 1, 1, 1, 0, "u 'TGDimension' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPosition(void) {
   /* TGPosition */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPosition));
   G__memfunc_setup("TGPosition",1008,G__G__Gui1_162_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPosition",1008,G__G__Gui1_162_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - xc i - 'Int_t' 0 - yc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPosition",1008,G__G__Gui1_162_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 1, 1, 1, 0, "u 'TGPosition' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Gui1_162_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGPosition' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Gui1_162_0_5, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 1, 1, 1, 8, "u 'TGPosition' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Gui1_162_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 1, 1, 1, 8, "u 'TGPosition' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_162_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPosition::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_162_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPosition::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_162_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPosition::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_162_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPosition::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_162_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_162_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui1_162_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui1_162_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_162_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPosition::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_162_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPosition::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_162_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPosition::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_162_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPosition::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGPosition", 1134, G__G__Gui1_162_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_162_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 1, 1, 1, 1, 0, "u 'TGPosition' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLongPosition(void) {
   /* TGLongPosition */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition));
   G__memfunc_setup("TGLongPosition",1408,G__G__Gui1_163_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLongPosition",1408,G__G__Gui1_163_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition), -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - xc l - 'Long_t' 0 - yc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLongPosition",1408,G__G__Gui1_163_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition), -1, 0, 1, 1, 1, 0, "u 'TGLongPosition' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Gui1_163_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLongPosition' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Gui1_163_0_5, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition), -1, 0, 1, 1, 1, 8, "u 'TGLongPosition' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Gui1_163_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition), -1, 0, 1, 1, 1, 8, "u 'TGLongPosition' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_163_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLongPosition::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_163_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLongPosition::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_163_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLongPosition::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_163_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLongPosition::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_163_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_163_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui1_163_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui1_163_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_163_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLongPosition::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_163_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLongPosition::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_163_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLongPosition::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_163_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLongPosition::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLongPosition", 1534, G__G__Gui1_163_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_163_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGLongPosition), -1, 1, 1, 1, 1, 0, "u 'TGLongPosition' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGInsets(void) {
   /* TGInsets */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInsets));
   G__memfunc_setup("TGInsets",785,G__G__Gui1_164_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGInsets), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGInsets",785,G__G__Gui1_164_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGInsets), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - lf i - 'Int_t' 0 - rg "
"i - 'Int_t' 0 - tp i - 'Int_t' 0 - bt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGInsets",785,G__G__Gui1_164_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGInsets), -1, 0, 1, 1, 1, 0, "u 'TGInsets' - 11 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Gui1_164_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGInsets' - 11 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_164_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGInsets::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_164_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGInsets::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_164_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGInsets::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_164_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGInsets::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_164_0_9, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_164_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui1_164_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui1_164_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_164_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGInsets::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_164_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGInsets::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_164_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGInsets::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_164_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGInsets::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGInsets", 911, G__G__Gui1_164_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_164_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGInsets), -1, 1, 1, 1, 1, 0, "u 'TGInsets' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRectangle(void) {
   /* TGRectangle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle));
   G__memfunc_setup("TGRectangle",1072,G__G__Gui1_165_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRectangle",1072,G__G__Gui1_165_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - rx i - 'Int_t' 0 - ry "
"h - 'UInt_t' 0 - rw h - 'UInt_t' 0 - rh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRectangle",1072,G__G__Gui1_165_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle), -1, 0, 2, 1, 1, 0, 
"u 'TGPosition' - 11 - p u 'TGDimension' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRectangle",1072,G__G__Gui1_165_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle), -1, 0, 1, 1, 1, 0, "u 'TGRectangle' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Gui1_165_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Gui1_165_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGPosition' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Intersects",1060,G__G__Gui1_165_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGRectangle' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Area",377,G__G__Gui1_165_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Size",411,G__G__Gui1_165_0_9, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LeftTop",702,G__G__Gui1_165_0_10, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RightBottom",1139,G__G__Gui1_165_0_11, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Gui1_165_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGRectangle' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Empty",527,G__G__Gui1_165_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEmpty",715,G__G__Gui1_165_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_165_0_15, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRectangle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_165_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRectangle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_165_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRectangle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_165_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRectangle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_165_0_19, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_165_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui1_165_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui1_165_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__Gui1_165_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRectangle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_165_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRectangle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_165_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRectangle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_165_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRectangle::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGRectangle", 1198, G__G__Gui1_165_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__Gui1_165_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGRectangle), -1, 1, 1, 1, 1, 0, "u 'TGRectangle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFrame(void) {
   /* TGFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrame));
   G__memfunc_setup("GetLastClick",1178,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Time_t"), 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   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("Draw3dRectangle",1466,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"h - 'UInt_t' 0 - type i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetResourcePool",1538,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGResourcePool), -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptionString",1552,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 2, 8, "", "used in SavePrimitive()", (void*) NULL, 0);
   G__memfunc_setup("StartGuiBuilding",1633,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGFrame",646,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 0, 1, 1, 4, 0, "u 'TGFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 1, 1, 1, 4, 0, "u 'TGFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFrameBackground",2512,G__G__Gui1_177_0_10, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixel_t (*)())(&TGFrame::GetDefaultFrameBackground) ), 0);
   G__memfunc_setup("GetDefaultSelectedBackground",2830,G__G__Gui1_177_0_11, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixel_t (*)())(&TGFrame::GetDefaultSelectedBackground) ), 0);
   G__memfunc_setup("GetWhitePixel",1315,G__G__Gui1_177_0_12, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixel_t (*)())(&TGFrame::GetWhitePixel) ), 0);
   G__memfunc_setup("GetBlackPixel",1279,G__G__Gui1_177_0_13, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixel_t (*)())(&TGFrame::GetBlackPixel) ), 0);
   G__memfunc_setup("GetBlackGC",903,G__G__Gui1_177_0_14, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGFrame::GetBlackGC) ), 0);
   G__memfunc_setup("GetWhiteGC",939,G__G__Gui1_177_0_15, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGFrame::GetWhiteGC) ), 0);
   G__memfunc_setup("GetHilightGC",1139,G__G__Gui1_177_0_16, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGFrame::GetHilightGC) ), 0);
   G__memfunc_setup("GetShadowGC",1040,G__G__Gui1_177_0_17, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGFrame::GetShadowGC) ), 0);
   G__memfunc_setup("GetBckgndGC",1011,G__G__Gui1_177_0_18, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGFrame::GetBckgndGC) ), 0);
   G__memfunc_setup("TGFrame",646,G__G__Gui1_177_0_19, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFrame",646,G__G__Gui1_177_0_20, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGClient' - 0 - c k - 'Window_t' 0 - id "
"U 'TGWindow' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteWindow",1227,G__G__Gui1_177_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReallyDelete",1212,G__G__Gui1_177_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEventMask",1198,G__G__Gui1_177_0_23, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInput",793,G__G__Gui1_177_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - emask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveInput",1150,G__G__Gui1_177_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - emask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleEvent",1102,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleConfigureNotify",2151,G__G__Gui1_177_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,G__G__Gui1_177_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDoubleClick",1677,G__G__Gui1_177_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,G__G__Gui1_177_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,G__G__Gui1_177_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,G__G__Gui1_177_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleFocusChange",1682,G__G__Gui1_177_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleClientMessage",1904,G__G__Gui1_177_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelection",1522,G__G__Gui1_177_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionRequest",2267,G__G__Gui1_177_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionClear",2009,G__G__Gui1_177_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleColormapChange",1999,G__G__Gui1_177_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragEnter",1480,G__G__Gui1_177_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragLeave",1463,G__G__Gui1_177_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragMotion",1600,G__G__Gui1_177_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragDrop",1375,G__G__Gui1_177_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - U 'TGLayoutHints' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessedConfigure",1866,G__G__Gui1_177_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ProcessedEvent",1450,G__G__Gui1_177_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("SendMessage",1103,G__G__Gui1_177_0_45, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - w l - 'Long_t' 0 - msg "
"l - 'Long_t' 0 - parm1 l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,G__G__Gui1_177_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - - l - 'Long_t' 0 - - "
"l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,G__G__Gui1_177_0_47, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Move",407,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,G__G__Gui1_177_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,G__G__Gui1_177_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGDimension' - 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveResize",1033,G__G__Gui1_177_0_51, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultWidth",1509,G__G__Gui1_177_0_52, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultHeight",1598,G__G__Gui1_177_0_53, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBackground",1312,G__G__Gui1_177_0_54, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeBackground",1606,G__G__Gui1_177_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - back", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBackgroundColor",1835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - back", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetForeground",1339,G__G__Gui1_177_0_57, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetForegroundColor",1862,G__G__Gui1_177_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOptions",1036,G__G__Gui1_177_0_59, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeOptions",1330,G__G__Gui1_177_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,G__G__Gui1_177_0_61, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapSubwindows",1363,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "Simple frames do not have subwindows", (void*) NULL, 1);
   G__memfunc_setup("ReparentWindow",1465,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p i - 'Int_t' 0 '0' x "
"i - 'Int_t' 0 '0' y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapWindow",918,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapRaised",886,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnmapWindow",1145,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,G__G__Gui1_177_0_67, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,G__G__Gui1_177_0_68, 121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Activate",817,G__G__Gui1_177_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,G__G__Gui1_177_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsComposite",1135,G__G__Gui1_177_0_71, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEditable",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditable",1094,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLayoutBroken",1547,G__G__Gui1_177_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLayoutBroken",1435,G__G__Gui1_177_0_75, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCleanup",1012,G__G__Gui1_177_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kLocalCleanup' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDragType",1100,G__G__Gui1_177_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDropType",1123,G__G__Gui1_177_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDragType",1088,G__G__Gui1_177_0_79, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDropType",1111,G__G__Gui1_177_0_80, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidth",800,G__G__Gui1_177_0_81, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeight",889,G__G__Gui1_177_0_82, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinWidth",1092,G__G__Gui1_177_0_83, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinHeight",1181,G__G__Gui1_177_0_84, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxWidth",1094,G__G__Gui1_177_0_85, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxHeight",1183,G__G__Gui1_177_0_86, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Gui1_177_0_87, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Gui1_177_0_88, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Gui1_177_0_89, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBorderWidth",1406,G__G__Gui1_177_0_90, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameElement",1493,G__G__Gui1_177_0_91, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameElement",1505,G__G__Gui1_177_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrameElement' - 0 - fe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Gui1_177_0_93, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFromPoint",1705,G__G__Gui1_177_0_94, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetX",388,G__G__Gui1_177_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetY",389,G__G__Gui1_177_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWidth",812,G__G__Gui1_177_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHeight",901,G__G__Gui1_177_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinWidth",1104,G__G__Gui1_177_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinHeight",1193,G__G__Gui1_177_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxWidth",1106,G__G__Gui1_177_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxHeight",1195,G__G__Gui1_177_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSize",711,G__G__Gui1_177_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGDimension' - 11 - s", (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("SaveUserColor",1325,G__G__Gui1_177_0_105, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 0);
   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("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("DrawClone",895,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_TObject), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 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("Dump",406,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (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("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("SetDNDSource",1139,G__G__Gui1_177_0_113, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDNDTarget",1129,G__G__Gui1_177_0_114, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - onoff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDNDSource",1027,G__G__Gui1_177_0_115, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDNDTarget",1017,G__G__Gui1_177_0_116, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDNDData",880,G__G__Gui1_177_0_117, 85, G__get_linked_tagnum(&G__G__Gui1LN_TDNDData), -1, 0, 1, 1, 1, 0, "k - 'Atom_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDDrop",1207,G__G__Gui1_177_0_118, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TDNDData' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDPosition",1655,G__G__Gui1_177_0_119, 107, -1, G__defined_typename("Atom_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"k - 'Atom_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDEnter",1312,G__G__Gui1_177_0_120, 107, -1, G__defined_typename("Atom_t"), 0, 1, 1, 1, 0, "K - 'Atom_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDLeave",1295,G__G__Gui1_177_0_121, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDFinished",1612,G__G__Gui1_177_0_122, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_177_0_123, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_177_0_124, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_177_0_125, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_177_0_126, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_177_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_177_0_131, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_177_0_132, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_177_0_133, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_177_0_134, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFrame", 772, G__G__Gui1_177_0_135, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGCompositeFrame(void) {
   /* TGCompositeFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame));
   G__memfunc_setup("TGCompositeFrame",1593,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame), -1, 0, 1, 1, 4, 0, "u 'TGCompositeFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame), -1, 1, 1, 1, 4, 0, "u 'TGCompositeFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGCompositeFrame",1593,G__G__Gui1_178_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGCompositeFrame",1593,G__G__Gui1_178_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCompositeFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGClient' - 0 - c k - 'Window_t' 0 - id "
"U 'TGWindow' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetList",700,G__G__Gui1_178_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultWidth",1509,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultHeight",1598,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFrameFromPoint",1705,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TranslateCoordinates",2089,G__G__Gui1_178_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"U 'TGFrame' - 0 - child i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y i - 'Int_t' 1 - fx "
"i - 'Int_t' 1 - fy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapSubwindows",1363,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDoubleClick",1677,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleFocusChange",1682,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelection",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragEnter",1480,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragLeave",1463,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragMotion",1600,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDragDrop",1375,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - frame i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y U 'TGLayoutHints' - 0 - lo", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeOptions",1330,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - - l - 'Long_t' 0 - - "
"l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLayoutManager",1625,G__G__Gui1_178_0_26, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLayoutManager",1637,G__G__Gui1_178_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLayoutManager' - 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFrameElement",1590,G__G__Gui1_178_0_28, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 0, 1, 1, 1, 8, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFrame",756,G__G__Gui1_178_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAll",903,G__G__Gui1_178_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFrame",1113,G__G__Gui1_178_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowFrame",908,G__G__Gui1_178_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HideFrame",869,G__G__Gui1_178_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetState",801,G__G__Gui1_178_0_34, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,G__G__Gui1_178_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,G__G__Gui1_178_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGFrameElement' - 0 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsArranged",992,G__G__Gui1_178_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsArranged",992,G__G__Gui1_178_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGFrameElement' - 0 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsComposite",1135,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEditable",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditable",1094,G__G__Gui1_178_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLayoutBroken",1547,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLayoutBroken",1435,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditDisabled",1482,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '1' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCleanup",1012,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kLocalCleanup' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MustCleanup",1137,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cleanup",712,G__G__Gui1_178_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMapSubwindows",1663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMapSubwindows",1551,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (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("ChangeSubframesBackground",2542,G__G__Gui1_178_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - back", (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("SavePrimitiveSubframes",2288,G__G__Gui1_178_0_53, 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("Class",502,G__G__Gui1_178_0_54, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGCompositeFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_178_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCompositeFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_178_0_56, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGCompositeFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_178_0_57, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGCompositeFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_178_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_178_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCompositeFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_178_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCompositeFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_178_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCompositeFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_178_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCompositeFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGCompositeFrame", 1719, G__G__Gui1_178_0_66, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLayoutHints(void) {
   /* TGLayoutHints */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints), -1, 1, 1, 1, 4, 0, "u 'TGLayoutHints' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateFrameElements",1931,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGLayoutHints' - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLayoutHints",1311,G__G__Gui1_179_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints), -1, 0, 5, 1, 1, 0, 
"k - 'ULong_t' 0 'kLHintsNormal' hints i - 'Int_t' 0 '0' padleft "
"i - 'Int_t' 0 '0' padright i - 'Int_t' 0 '0' padtop "
"i - 'Int_t' 0 '0' padbottom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLayoutHints",1311,G__G__Gui1_179_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutHints), -1, 0, 1, 1, 1, 0, "u 'TGLayoutHints' - 11 - lh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLayoutHints",1444,G__G__Gui1_179_0_5, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadTop",872,G__G__Gui1_179_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadBottom",1194,G__G__Gui1_179_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadLeft",960,G__G__Gui1_179_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadRight",1075,G__G__Gui1_179_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLayoutHints",1456,G__G__Gui1_179_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - lh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPadTop",884,G__G__Gui1_179_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPadBottom",1206,G__G__Gui1_179_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPadLeft",972,G__G__Gui1_179_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPadRight",1087,G__G__Gui1_179_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (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("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("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("Class",502,G__G__Gui1_179_0_18, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLayoutHints::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_179_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLayoutHints::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_179_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLayoutHints::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_179_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLayoutHints::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_179_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__Gui1_179_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLayoutHints::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_179_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLayoutHints::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_179_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLayoutHints::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_179_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLayoutHints::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLayoutHints", 1437, G__G__Gui1_179_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFrameElement(void) {
   /* TGFrameElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement));
   G__memfunc_setup("TGFrameElement",1360,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 0, 1, 1, 4, 0, "u 'TGFrameElement' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 1, 1, 1, 4, 0, "u 'TGFrameElement' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFrameElement",1360,G__G__Gui1_180_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFrameElement",1360,G__G__Gui1_180_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 - l", (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("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__Gui1_180_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFrameElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_180_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrameElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_180_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFrameElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_180_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFrameElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_180_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_180_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrameElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_180_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFrameElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_180_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrameElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_180_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFrameElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFrameElement", 1486, G__G__Gui1_180_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLayoutManager(void) {
   /* TGLayoutManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager));
   G__memfunc_setup("Layout",638,G__G__Gui1_181_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetDefaultSize",1408,G__G__Gui1_181_0_3, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetDefaultWidth",1521,G__G__Gui1_181_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultHeight",1610,G__G__Gui1_181_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsModified",989,G__G__Gui1_181_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModified",1101,G__G__Gui1_181_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_181_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLayoutManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_181_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLayoutManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_181_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLayoutManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_181_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLayoutManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_181_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__Gui1_181_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLayoutManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_181_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLayoutManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_181_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLayoutManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_181_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLayoutManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLayoutManager", 1618, G__G__Gui1_181_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_181_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager), -1, 1, 1, 1, 1, 0, "u 'TGLayoutManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVerticalLayout(void) {
   /* TGVerticalLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout));
   G__memfunc_setup("TGVerticalLayout",1619,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout), -1, 0, 1, 1, 2, 0, "u 'TGVerticalLayout' - 11 - gvl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout), -1, 1, 1, 1, 2, 0, "u 'TGVerticalLayout' - 11 - gvl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGVerticalLayout",1619,G__G__Gui1_182_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalLayout), -1, 0, 1, 1, 1, 0, "U 'TGCompositeFrame' - 0 - main", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_182_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVerticalLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_182_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVerticalLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_182_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVerticalLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_182_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVerticalLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_182_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_182_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVerticalLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_182_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVerticalLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_182_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVerticalLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_182_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVerticalLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVerticalLayout", 1745, G__G__Gui1_182_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHorizontalLayout(void) {
   /* TGHorizontalLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout));
   G__memfunc_setup("TGHorizontalLayout",1859,G__G__Gui1_183_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout), -1, 0, 1, 1, 1, 0, "U 'TGCompositeFrame' - 0 - main", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_183_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHorizontalLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_183_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontalLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_183_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHorizontalLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_183_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHorizontalLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_183_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_183_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontalLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_183_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHorizontalLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_183_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontalLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_183_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHorizontalLayout::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGHorizontalLayout", 1859, G__G__Gui1_183_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalLayout), -1, 0, 1, 1, 1, 0, "u 'TGHorizontalLayout' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGHorizontalLayout", 1985, G__G__Gui1_183_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRowLayout(void) {
   /* TGRowLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout));
   G__memfunc_setup("TGRowLayout",1105,G__G__Gui1_184_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout), -1, 0, 2, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main i - 'Int_t' 0 '0' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_184_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRowLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_184_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRowLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_184_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRowLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_184_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRowLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_184_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_184_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRowLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_184_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRowLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_184_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRowLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_184_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRowLayout::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGRowLayout", 1105, G__G__Gui1_184_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGRowLayout), -1, 0, 1, 1, 1, 0, "u 'TGRowLayout' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGRowLayout", 1231, G__G__Gui1_184_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGColumnLayout(void) {
   /* TGColumnLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout));
   G__memfunc_setup("TGColumnLayout",1415,G__G__Gui1_185_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout), -1, 0, 2, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main i - 'Int_t' 0 '0' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_185_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGColumnLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_185_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColumnLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_185_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGColumnLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_185_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGColumnLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_185_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_185_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColumnLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_185_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColumnLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_185_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGColumnLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_185_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGColumnLayout::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGColumnLayout", 1415, G__G__Gui1_185_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGColumnLayout), -1, 0, 1, 1, 1, 0, "u 'TGColumnLayout' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGColumnLayout", 1541, G__G__Gui1_185_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMatrixLayout(void) {
   /* TGMatrixLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout));
   G__memfunc_setup("TGMatrixLayout",1422,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout), -1, 0, 1, 1, 4, 0, "u 'TGMatrixLayout' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout), -1, 1, 1, 1, 4, 0, "u 'TGMatrixLayout' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMatrixLayout",1422,G__G__Gui1_186_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMatrixLayout), -1, 0, 5, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main h - 'UInt_t' 0 - r "
"h - 'UInt_t' 0 - c i - 'Int_t' 0 '0' s "
"i - 'Int_t' 0 '0' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_186_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMatrixLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_186_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMatrixLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_186_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMatrixLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_186_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMatrixLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_186_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_186_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMatrixLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_186_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMatrixLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_186_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMatrixLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_186_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMatrixLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMatrixLayout", 1548, G__G__Gui1_186_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTileLayout(void) {
   /* TGTileLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout));
   G__memfunc_setup("TGTileLayout",1191,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout), -1, 0, 1, 1, 4, 0, "u 'TGTileLayout' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout), -1, 1, 1, 1, 4, 0, "u 'TGTileLayout' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTileLayout",1191,G__G__Gui1_187_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTileLayout), -1, 0, 2, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main i - 'Int_t' 0 '0' sep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsModified",989,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_187_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTileLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_187_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTileLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_187_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTileLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_187_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTileLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_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__Gui1_187_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTileLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_187_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTileLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_187_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTileLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_187_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTileLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTileLayout", 1317, G__G__Gui1_187_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListLayout(void) {
   /* TGListLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout));
   G__memfunc_setup("TGListLayout",1205,G__G__Gui1_188_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGListLayout), -1, 0, 2, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main i - 'Int_t' 0 '0' sep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_188_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_188_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_188_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_188_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_188_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_188_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_188_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_188_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_188_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListLayout", 1331, G__G__Gui1_188_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListDetailsLayout(void) {
   /* TGListDetailsLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout));
   G__memfunc_setup("TGListDetailsLayout",1915,G__G__Gui1_189_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGListDetailsLayout), -1, 0, 3, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main i - 'Int_t' 0 '0' sep "
"h - 'UInt_t' 0 '0' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultWidth",1521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - w", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_189_0_6, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListDetailsLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_189_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListDetailsLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_189_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListDetailsLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_189_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListDetailsLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_189_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__Gui1_189_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListDetailsLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_189_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListDetailsLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_189_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListDetailsLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_189_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListDetailsLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListDetailsLayout", 2041, G__G__Gui1_189_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGString(void) {
   /* TGString */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGString));
   G__memfunc_setup("TGString",786,G__G__Gui1_190_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGString",786,G__G__Gui1_190_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGString",786,G__G__Gui1_190_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGString",786,G__G__Gui1_190_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 1, 1, 1, 0, "U 'TGString' - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLength",898,G__G__Gui1_190_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetString",919,G__G__Gui1_190_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetString",931,G__G__Gui1_190_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Gui1_190_0_8, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawWrapped",1121,G__G__Gui1_190_0_9, 121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w k - 'FontStruct_t' 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLines",795,G__G__Gui1_190_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font h - 'UInt_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_190_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGString::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_190_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGString::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_190_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGString::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_190_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGString::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_190_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__Gui1_190_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGString::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_190_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGString::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_190_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGString::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_190_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGString::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGString", 786, G__G__Gui1_190_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 1, 1, 1, 0, "u 'TGString' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGString", 912, G__G__Gui1_190_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_190_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 1, 1, 1, 1, 0, "u 'TGString' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHotString(void) {
   /* TGHotString */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHotString));
   G__memfunc_setup("DrawHotChar",1079,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGHotString",1085,G__G__Gui1_191_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHotString), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHotChar",969,G__G__Gui1_191_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHotPos",893,G__G__Gui1_191_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawWrapped",1121,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"k - 'Drawable_t' 0 - id k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w k - 'FontStruct_t' 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_191_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHotString::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_191_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHotString::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_191_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHotString::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_191_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHotString::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_191_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_191_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHotString::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_191_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHotString::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_191_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHotString::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_191_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHotString::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGHotString", 1085, G__G__Gui1_191_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGHotString), -1, 0, 1, 1, 1, 0, "u 'TGHotString' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGHotString", 1211, G__G__Gui1_191_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui1_191_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGHotString), -1, 1, 1, 1, 1, 0, "u 'TGHotString' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextButton(void) {
   /* TGTextButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGTextButton",1212,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton), -1, 0, 1, 1, 4, 0, "u 'TGTextButton' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton), -1, 1, 1, 1, 4, 0, "u 'TGTextButton' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_202_0_5, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGTextButton::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("TGTextButton",1212,G__G__Gui1_202_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGHotString' - 0 - s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextButton",1212,G__G__Gui1_202_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextButton",1212,G__G__Gui1_202_0_8, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextButton), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - s "
"C - - 10 - cmd i - 'Int_t' 0 '-1' id "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,G__G__Gui1_202_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGHotString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetString",919,G__G__Gui1_202_0_13, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextJustify",1471,G__G__Gui1_202_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tmode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextJustify",1459,G__G__Gui1_202_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__Gui1_202_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGHotString' - 0 - new_label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui1_202_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - new_label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Gui1_202_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui1_202_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui1_202_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fontName g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_202_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Pixel_t' 0 - color g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetForegroundColor",1862,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - fore", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasOwnFont",999,G__G__Gui1_202_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWrapLength",1320,G__G__Gui1_202_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWrapLength",1308,G__G__Gui1_202_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMargins",1021,G__G__Gui1_202_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '0' left i - 'Int_t' 0 '0' right "
"i - 'Int_t' 0 '0' top i - 'Int_t' 0 '0' bottom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLeftMargin",1301,G__G__Gui1_202_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRightMargin",1416,G__G__Gui1_202_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTopMargin",1213,G__G__Gui1_202_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBottomMargin",1535,G__G__Gui1_202_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLeftMargin",1289,G__G__Gui1_202_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightMargin",1404,G__G__Gui1_202_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopMargin",1201,G__G__Gui1_202_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBottomMargin",1523,G__G__Gui1_202_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeText",1003,G__G__Gui1_202_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", "*MENU*icon=bld_rename.png*", (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui1_202_0_36, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("Class",502,G__G__Gui1_202_0_39, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_202_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_202_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_202_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_202_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_202_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_202_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_202_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_202_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextButton", 1338, G__G__Gui1_202_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVerticalFrame(void) {
   /* TGVerticalFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame));
   G__memfunc_setup("TGVerticalFrame",1472,G__G__Gui1_211_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVerticalFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_211_0_3, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVerticalFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_211_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVerticalFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_211_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVerticalFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_211_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVerticalFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_211_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_211_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVerticalFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_211_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVerticalFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_211_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVerticalFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_211_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVerticalFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVerticalFrame", 1598, G__G__Gui1_211_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHorizontalFrame(void) {
   /* TGHorizontalFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame));
   G__memfunc_setup("TGHorizontalFrame",1712,G__G__Gui1_212_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontalFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_212_0_3, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHorizontalFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_212_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontalFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_212_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHorizontalFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_212_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHorizontalFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_212_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_212_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontalFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_212_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHorizontalFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_212_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontalFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_212_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHorizontalFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHorizontalFrame", 1838, G__G__Gui1_212_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMainFrame(void) {
   /* TGMainFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame));
   G__memfunc_setup("GetMWMvalueString",1701,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 2, 8, "", "used in SaveSource()", (void*) NULL, 0);
   G__memfunc_setup("GetMWMfuncString",1588,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 2, 8, "", "used in SaveSource()", (void*) NULL, 0);
   G__memfunc_setup("GetMWMinpString",1487,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 2, 8, "", "used in SaveSource()", (void*) NULL, 0);
   G__memfunc_setup("TGMainFrame",1035,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame), -1, 0, 1, 1, 4, 0, "u 'TGMainFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame), -1, 1, 1, 1, 4, 0, "u 'TGMainFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGMainFrame",1035,G__G__Gui1_213_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMainFrame), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 'kVerticalFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleClientMessage",1904,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelection",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionRequest",2267,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveFrameAsCodeOrImage",2125,G__G__Gui1_213_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SendCloseMessage",1605,G__G__Gui1_213_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,G__G__Gui1_213_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DontCallClose",1287,G__G__Gui1_213_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWindowName",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIconName",1078,G__G__Gui1_213_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIconPixmap",1316,G__G__Gui1_213_0_19, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 1, 1, 1, 1, "C - - 10 - iconName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIconPixmap",1316,G__G__Gui1_213_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 2 - xpm_array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClassHints",1320,G__G__Gui1_213_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - className C - - 10 - resourceName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMWMHints",1059,G__G__Gui1_213_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - value h - 'UInt_t' 0 - funcs "
"h - 'UInt_t' 0 - input", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWMPosition",1317,G__G__Gui1_213_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWMSize",875,G__G__Gui1_213_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWMSizeHints",1393,G__G__Gui1_213_0_25, 121, -1, -1, 0, 6, 1, 1, 0, 
"h - 'UInt_t' 0 - wmin h - 'UInt_t' 0 - hmin "
"h - 'UInt_t' 0 - wmax h - 'UInt_t' 0 - hmax "
"h - 'UInt_t' 0 - winc h - 'UInt_t' 0 - hinc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWMState",977,G__G__Gui1_213_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EInitialState' - 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BindKey",678,G__G__Gui1_213_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"U 'TGWindow' - 10 - w i - 'Int_t' 0 - keycode "
"i - 'Int_t' 0 - modifier", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveBind",1003,G__G__Gui1_213_0_28, 121, -1, -1, 0, 3, 1, 1, 8, 
"U 'TGWindow' - 10 - w i - 'Int_t' 0 - keycode "
"i - 'Int_t' 0 - modifier", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBindList",1081,G__G__Gui1_213_0_29, 85, G__get_linked_tagnum(&G__G__Gui1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowName",1305,G__G__Gui1_213_0_30, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIconPixmap",1304,G__G__Gui1_213_0_32, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassHints",1308,G__G__Gui1_213_0_33, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 11 - className C - - 11 - resourceName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMWMHints",1047,G__G__Gui1_213_0_34, 121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 1 - value h - 'UInt_t' 1 - funcs "
"h - 'UInt_t' 1 - input", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWMPosition",1305,G__G__Gui1_213_0_35, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 1 - x i - 'Int_t' 1 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWMSize",863,G__G__Gui1_213_0_36, 121, -1, -1, 0, 2, 1, 1, 8, 
"h - 'UInt_t' 1 - w h - 'UInt_t' 1 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWMSizeHints",1381,G__G__Gui1_213_0_37, 121, -1, -1, 0, 6, 1, 1, 8, 
"h - 'UInt_t' 1 - wmin h - 'UInt_t' 1 - hmin "
"h - 'UInt_t' 1 - wmax h - 'UInt_t' 1 - hmax "
"h - 'UInt_t' 1 - winc h - 'UInt_t' 1 - hinc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWMState",965,G__G__Gui1_213_0_38, 105, G__get_linked_tagnum(&G__G__Gui1LN_EInitialState), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("SaveSource",1024,G__G__Gui1_213_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"Rootappl.C\"' filename C - 'Option_t' 10 '\"\"' option", "*MENU*icon=bld_save.png*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_213_0_41, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMainFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_213_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMainFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_213_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMainFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_213_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMainFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_213_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_213_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMainFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_213_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMainFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_213_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMainFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_213_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMainFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMainFrame", 1161, G__G__Gui1_213_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTransientFrame(void) {
   /* TGTransientFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame));
   G__memfunc_setup("TGTransientFrame",1598,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame), -1, 0, 1, 1, 4, 0, "u 'TGTransientFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame), -1, 1, 1, 1, 4, 0, "u 'TGTransientFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGTransientFrame",1598,G__G__Gui1_216_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTransientFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGWindow' - 10 '0' main "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h "
"h - 'UInt_t' 0 'kVerticalFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CenterOnParent",1416,G__G__Gui1_216_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' croot i 'TGTransientFrame::EPlacement' - 0 'kCenter' pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMain",677,G__G__Gui1_216_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGWindow), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   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("SaveSource",1024,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"Rootdlog.C\"' filename C - 'Option_t' 10 '\"\"' option", "*MENU*icon=bld_save.png*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_216_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTransientFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_216_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTransientFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_216_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTransientFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_216_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTransientFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_216_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__Gui1_216_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTransientFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_216_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTransientFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_216_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTransientFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_216_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTransientFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTransientFrame", 1724, G__G__Gui1_216_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGGroupFrame(void) {
   /* TGGroupFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGGroupFrame",1171,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame), -1, 0, 1, 1, 4, 0, "u 'TGGroupFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame), -1, 1, 1, 1, 4, 0, "u 'TGGroupFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_218_0_4, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGGroupFrame::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_218_0_5, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGGroupFrame::GetDefaultGC) ), 0);
   G__memfunc_setup("TGGroupFrame",1171,G__G__Gui1_218_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGString' - 0 - title "
"h - 'UInt_t' 0 'kVerticalFrame' options k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGGroupFrame",1171,G__G__Gui1_218_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGGroupFrame), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' title "
"h - 'UInt_t' 0 'kVerticalFrame' options k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Gui1_218_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGString' - 0 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Gui1_218_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rename",600,G__G__Gui1_218_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", "*MENU*icon=bld_rename.png*", (void*) NULL, 1);
   G__memfunc_setup("GetTitlePos",1108,G__G__Gui1_218_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitlePos",1120,G__G__Gui1_218_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGGroupFrame::ETitlePos' - 0 'kLeft' pos", "*SUBMENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_218_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Pixel_t' 0 - color g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,G__G__Gui1_218_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fontName g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,G__G__Gui1_218_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNormGC",838,G__G__Gui1_218_0_18, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui1_218_0_19, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasOwnFont",999,G__G__Gui1_218_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_218_0_23, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGGroupFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_218_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGroupFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_218_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGGroupFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_218_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGGroupFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_218_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__Gui1_218_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGroupFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_218_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGroupFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_218_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGroupFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_218_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGroupFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGGroupFrame", 1297, G__G__Gui1_218_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHeaderFrame(void) {
   /* TGHeaderFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame));
   G__memfunc_setup("TGHeaderFrame",1231,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame), -1, 0, 1, 1, 4, 0, "u 'TGHeaderFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame), -1, 1, 1, 1, 4, 0, "u 'TGHeaderFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGHeaderFrame",1231,G__G__Gui1_220_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHeaderFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDoubleClick",1677,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColumnsInfo",1433,G__G__Gui1_220_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nColumns U 'TGTextButton' - 2 - colHeader "
"U 'TGVFileSplitter' - 2 - splitHeader", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_220_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHeaderFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_220_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHeaderFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_220_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHeaderFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_220_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHeaderFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_220_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__Gui1_220_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHeaderFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_220_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHeaderFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_220_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHeaderFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_220_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHeaderFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHeaderFrame", 1357, G__G__Gui1_220_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGWidget(void) {
   /* TGWidget */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGWidget));
   G__memfunc_setup("TGWidget",767,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWidget), -1, 0, 1, 1, 2, 0, "u 'TGWidget' - 11 - tgw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGWidget), -1, 1, 1, 1, 2, 0, "u 'TGWidget' - 11 - tgw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlags",793,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - flags", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearFlags",980,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - flags", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGWidget",767,G__G__Gui1_224_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWidget), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGWidget",767,G__G__Gui1_224_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGWidget), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WidgetId",785,G__G__Gui1_224_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEnabled",871,G__G__Gui1_224_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasFocus",796,G__G__Gui1_224_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WantFocus",922,G__G__Gui1_224_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Associate",924,G__G__Gui1_224_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCommand",1003,G__G__Gui1_224_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - command", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCommand",991,G__G__Gui1_224_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_224_0_14, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGWidget::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_224_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGWidget::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_224_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGWidget::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_224_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGWidget::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_224_0_18, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_224_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__Gui1_224_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__Gui1_224_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__Gui1_224_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGWidget::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_224_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGWidget::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_224_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGWidget::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_224_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGWidget::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGWidget", 893, G__G__Gui1_224_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGIcon(void) {
   /* TGIcon */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGIcon));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGIcon",548,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGIcon), -1, 0, 1, 1, 4, 0, "u 'TGIcon' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGIcon), -1, 1, 1, 1, 4, 0, "u 'TGIcon' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGIcon",548,G__G__Gui1_226_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGIcon), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"h - 'UInt_t' 0 'kChildFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGIcon",548,G__G__Gui1_226_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGIcon), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' image", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Gui1_226_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_226_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImage",771,G__G__Gui1_226_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TImage), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPicture",1032,G__G__Gui1_226_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Gui1_226_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - img", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImage",783,G__G__Gui1_226_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TImage' - 0 - img", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetImagePath",1180,G__G__Gui1_226_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGDimension' - 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveResize",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeBackgroundColor",2117,G__G__Gui1_226_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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("Class",502,G__G__Gui1_226_0_19, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGIcon::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_226_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIcon::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_226_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGIcon::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_226_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGIcon::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_226_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__Gui1_226_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIcon::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_226_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGIcon::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_226_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIcon::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_226_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGIcon::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGIcon", 674, G__G__Gui1_226_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLabel(void) {
   /* TGLabel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGLabel));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLabel",635,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLabel), -1, 0, 1, 1, 4, 0, "u 'TGLabel' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGLabel), -1, 1, 1, 1, 4, 0, "u 'TGLabel' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_228_0_5, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGLabel::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_228_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGLabel::GetDefaultGC) ), 0);
   G__memfunc_setup("TGLabel",635,G__G__Gui1_228_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLabel), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGString' - 0 - text "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"h - 'UInt_t' 0 'kChildFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLabel",635,G__G__Gui1_228_0_8, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGLabel), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' text "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"h - 'UInt_t' 0 'kChildFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,G__G__Gui1_228_0_10, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui1_228_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGString' - 0 - newText", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui1_228_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - newText", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeText",1003,G__G__Gui1_228_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - newText", "*MENU*icon=bld_rename.png*", (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Gui1_228_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui1_228_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextJustify",1471,G__G__Gui1_228_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tmode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextJustify",1459,G__G__Gui1_228_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextFont",1128,G__G__Gui1_228_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFont' - 0 - font g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,G__G__Gui1_228_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,G__G__Gui1_228_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fontName g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_228_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Pixel_t' 0 - color g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_228_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TColor' - 0 - color g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetForegroundColor",1862,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - fore", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Disable",692,G__G__Gui1_228_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "*TOGGLE* *GETTER=IsDisabled", (void*) NULL, 1);
   G__memfunc_setup("Enable",583,G__G__Gui1_228_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDisabled",980,G__G__Gui1_228_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasOwnFont",999,G__G__Gui1_228_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWrapLength",1320,G__G__Gui1_228_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - wl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWrapLength",1308,G__G__Gui1_228_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set3DStyle",948,G__G__Gui1_228_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get3DStyle",936,G__G__Gui1_228_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMargins",1021,G__G__Gui1_228_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '0' left i - 'Int_t' 0 '0' right "
"i - 'Int_t' 0 '0' top i - 'Int_t' 0 '0' bottom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftMargin",1289,G__G__Gui1_228_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightMargin",1404,G__G__Gui1_228_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopMargin",1201,G__G__Gui1_228_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBottomMargin",1523,G__G__Gui1_228_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormGC",838,G__G__Gui1_228_0_38, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui1_228_0_39, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui1_228_0_40, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFont), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("Class",502,G__G__Gui1_228_0_43, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLabel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_228_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLabel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_228_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLabel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_228_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLabel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_228_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_228_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLabel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_228_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLabel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_228_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLabel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_228_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLabel::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLabel", 761, G__G__Gui1_228_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGButtonGroup(void) {
   /* TGButtonGroup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup));
   G__memfunc_setup("TGButtonGroup",1316,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup), -1, 0, 1, 1, 4, 0, "u 'TGButtonGroup' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup), -1, 1, 1, 1, 4, 0, "u 'TGButtonGroup' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGButtonGroup",1316,G__G__Gui1_231_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent u 'TString' - 11 '\"\"' title "
"h - 'UInt_t' 0 'kChildFrame|kVerticalFrame' options k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGButtonGroup",1316,G__G__Gui1_231_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 - parent h - 'UInt_t' 0 - r "
"h - 'UInt_t' 0 - c i - 'Int_t' 0 '0' s "
"i - 'Int_t' 0 '0' h u 'TString' - 11 '\"\"' title "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Pressed",726,G__G__Gui1_231_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Released",805,G__G__Gui1_231_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui1_231_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ButtonPressed",1362,G__G__Gui1_231_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ButtonReleased",1441,G__G__Gui1_231_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ButtonClicked",1323,G__G__Gui1_231_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReleaseButtons",1456,G__G__Gui1_231_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEnabled",871,G__G__Gui1_231_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsExclusive",1140,G__G__Gui1_231_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRadioButtonExclusive",2271,G__G__Gui1_231_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBorderDrawn",1302,G__G__Gui1_231_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__G__Gui1_231_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetId",461,G__G__Gui1_231_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TGButton' - 0 - button", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExclusive",1252,G__G__Gui1_231_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRadioButtonExclusive",2383,G__G__Gui1_231_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,G__G__Gui1_231_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBorderDrawn",1414,G__G__Gui1_231_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetButton",936,G__G__Gui1_231_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - id g - 'Bool_t' 0 'kTRUE' down", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGString' - 0 - title", (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("Insert",629,G__G__Gui1_231_0_27, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGButton' - 0 - button i - - 0 '-1' id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Gui1_231_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGButton' - 0 - button", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Find",385,G__G__Gui1_231_0_29, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetButton",924,G__G__Gui1_231_0_30, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Gui1_231_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hide",378,G__G__Gui1_231_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLayoutHints",1456,G__G__Gui1_231_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLayoutHints' - 0 - l U 'TGButton' - 0 '0' button", (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("Class",502,G__G__Gui1_231_0_36, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGButtonGroup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_231_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGButtonGroup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_231_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGButtonGroup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_231_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGButtonGroup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_231_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_231_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGButtonGroup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_231_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGButtonGroup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_231_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGButtonGroup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_231_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGButtonGroup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGButtonGroup", 1442, G__G__Gui1_231_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPopupMenu(void) {
   /* TGPopupMenu */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu));
   G__memfunc_setup("DrawTrianglePattern",1954,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - l "
"i - 'Int_t' 0 - t i - 'Int_t' 0 - r "
"i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCheckMark",1271,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - l "
"i - 'Int_t' 0 - t i - 'Int_t' 0 - r "
"i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRCheckMark",1353,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"k - 'GContext_t' 0 - gc i - 'Int_t' 0 - l "
"i - 'Int_t' 0 - t i - 'Int_t' 0 - r "
"i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawEntry",928,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGMenuEntry' - 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reposition",1068,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultFontStruct",2049,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHilightFontStruct",2053,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultGC",1135,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSelectedGC",1944,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSelectedBackgroundGC",2968,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPopupMenu",1092,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 1, 1, 4, 0, "u 'TGPopupMenu' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 1, 1, 1, 4, 0, "u 'TGPopupMenu' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGPopupMenu",1092,G__G__Gui1_232_0_14, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '10' w "
"h - 'UInt_t' 0 '10' h h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEntry",795,G__G__Gui1_232_0_15, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TGHotString' - 0 - s i - 'Int_t' 0 - id "
"Y - - 0 '0' ud U 'TGPicture' - 10 '0' p "
"U 'TGMenuEntry' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntry",795,G__G__Gui1_232_0_16, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - id "
"Y - - 0 '0' ud U 'TGPicture' - 10 '0' p "
"U 'TGMenuEntry' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddSeparator",1210,G__G__Gui1_232_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMenuEntry' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLabel",745,G__G__Gui1_232_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGHotString' - 0 - s U 'TGPicture' - 10 '0' p "
"U 'TGMenuEntry' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLabel",745,G__G__Gui1_232_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - s U 'TGPicture' - 10 '0' p "
"U 'TGMenuEntry' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddPopup",797,G__G__Gui1_232_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGHotString' - 0 - s U 'TGPopupMenu' - 0 - popup "
"U 'TGMenuEntry' - 0 '0' before U 'TGPicture' - 10 '0' p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddPopup",797,G__G__Gui1_232_0_21, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - s U 'TGPopupMenu' - 0 - popup "
"U 'TGMenuEntry' - 0 '0' before U 'TGPicture' - 10 '0' p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableEntry",1113,G__G__Gui1_232_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisableEntry",1222,G__G__Gui1_232_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEntryEnabled",1401,G__G__Gui1_232_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HideEntry",908,G__G__Gui1_232_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEntryHidden",1306,G__G__Gui1_232_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefaultEntry",1239,G__G__Gui1_232_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckEntry",1008,G__G__Gui1_232_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckEntryByData",1573,G__G__Gui1_232_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - user_data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnCheckEntry",1203,G__G__Gui1_232_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnCheckEntryByData",1768,G__G__Gui1_232_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - user_data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnCheckEntries",1403,G__G__Gui1_232_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEntryChecked",1397,G__G__Gui1_232_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RCheckEntry",1090,G__G__Gui1_232_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - IDfirst "
"i - 'Int_t' 0 - IDlast", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEntryRChecked",1479,G__G__Gui1_232_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PlaceMenu",890,G__G__Gui1_232_0_36, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"g - 'Bool_t' 0 - stick_mode g - 'Bool_t' 0 - grab_pointer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EndMenu",684,G__G__Gui1_232_0_37, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "Y - - 1 - userData", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteEntry",1125,G__G__Gui1_232_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteEntry",1125,G__G__Gui1_232_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMenuEntry' - 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,G__G__Gui1_232_0_40, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrent",1027,G__G__Gui1_232_0_41, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,G__G__Gui1_232_0_42, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfEntries",1611,G__G__Gui1_232_0_43, 85, G__get_linked_tagnum(&G__G__Gui1LN_TList), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Associate",924,G__G__Gui1_232_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMenuBar",982,G__G__Gui1_232_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMenuBar' - 0 - bar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMenuBar",970,G__G__Gui1_232_0_51, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Activate",817,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Activate",817,G__G__Gui1_232_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGMenuEntry' - 0 - entry", (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("GetEntrySep",1114,G__G__Gui1_232_0_55, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntrySep",1126,G__G__Gui1_232_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - sep", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PoppedUp",813,G__G__Gui1_232_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("PoppedDown",1024,G__G__Gui1_232_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Highlighted",1121,G__G__Gui1_232_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Activated",917,G__G__Gui1_232_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_232_0_61, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPopupMenu::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_232_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPopupMenu::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_232_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPopupMenu::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_232_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPopupMenu::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_232_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_232_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPopupMenu::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_232_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPopupMenu::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_232_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPopupMenu::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_232_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPopupMenu::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGPopupMenu", 1218, G__G__Gui1_232_0_73, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGButton(void) {
   /* TGButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGButton));
   G__memfunc_setup("SetToggleButton",1546,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EmitSignals",1120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - wasUp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGButton",791,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 1, 1, 4, 0, "u 'TGButton' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 1, 1, 1, 4, 0, "u 'TGButton' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_233_0_5, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGButton::GetDefaultGC) ), 0);
   G__memfunc_setup("GetHibckgndGC",1220,G__G__Gui1_233_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGButton::GetHibckgndGC) ), 0);
   G__memfunc_setup("TGButton",791,G__G__Gui1_233_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUserData",1093,G__G__Gui1_233_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - userData", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserData",1081,G__G__Gui1_233_0_11, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetToolTipText",1436,G__G__Gui1_233_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text l - 'Long_t' 0 '400' delayms", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetToolTip",1003,G__G__Gui1_233_0_13, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGToolTip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,G__G__Gui1_233_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'EButtonState' - 0 - state g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetState",801,G__G__Gui1_233_0_15, 105, G__get_linked_tagnum(&G__G__Gui1LN_EButtonState), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AllowStayDown",1336,G__G__Gui1_233_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGroup",825,G__G__Gui1_233_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGButtonGroup' - 0 - gr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGroup",813,G__G__Gui1_233_0_18, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGButtonGroup), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDown",596,G__G__Gui1_233_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDown",708,G__G__Gui1_233_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOn",377,G__G__Gui1_233_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOn",489,G__G__Gui1_233_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsToggleButton",1434,G__G__Gui1_233_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsExclusiveToggle",1750,G__G__Gui1_233_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Toggle",610,G__G__Gui1_233_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEnabled",983,G__G__Gui1_233_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' e", "*TOGGLE* *GETTER=IsEnabled", (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("GetNormGC",838,G__G__Gui1_233_0_28, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Pressed",726,G__G__Gui1_233_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Released",805,G__G__Gui1_233_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui1_233_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Toggled",710,G__G__Gui1_233_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_233_0_33, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_233_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_233_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_233_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_233_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_233_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_233_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_233_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_233_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGButton", 917, G__G__Gui1_233_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPictureButton(void) {
   /* TGPictureButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateDisabledPicture",2120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGPictureButton",1523,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton), -1, 0, 1, 1, 4, 0, "u 'TGPictureButton' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton), -1, 1, 1, 1, 4, 0, "u 'TGPictureButton' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGPictureButton",1523,G__G__Gui1_234_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPictureButton",1523,G__G__Gui1_234_0_6, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
"C - - 10 - cmd i - 'Int_t' 0 '-1' id "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPictureButton",1523,G__G__Gui1_234_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPictureButton), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' pic "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPicture",1032,G__G__Gui1_234_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - new_pic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDisabledPicture",1824,G__G__Gui1_234_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPicture",1020,G__G__Gui1_234_0_10, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDisabledPicture",1812,G__G__Gui1_234_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_234_0_13, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPictureButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_234_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPictureButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_234_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPictureButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_234_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPictureButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_234_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__Gui1_234_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPictureButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_234_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPictureButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_234_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPictureButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_234_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPictureButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGPictureButton", 1649, G__G__Gui1_234_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGCheckButton(void) {
   /* TGCheckButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton));
   G__memfunc_setup("TGCheckButton",1269,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton), -1, 0, 1, 1, 4, 0, "u 'TGCheckButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton), -1, 1, 1, 1, 4, 0, "u 'TGCheckButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PSetState",893,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i 'EButtonState' - 0 - state g - 'Bool_t' 0 - emit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EmitSignals",1120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' wasUp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_235_0_7, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGCheckButton::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_235_0_8, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGCheckButton::GetDefaultGC) ), 0);
   G__memfunc_setup("TGCheckButton",1269,G__G__Gui1_235_0_9, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGHotString' - 0 - s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGCheckButton",1269,G__G__Gui1_235_0_10, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGCheckButton",1269,G__G__Gui1_235_0_11, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGCheckButton), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - s "
"C - - 10 - cmd i - 'Int_t' 0 '-1' id "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsToggleButton",1434,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOn",377,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDown",596,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDisabledAndSelected",2064,G__G__Gui1_235_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDisabledAndSelected",2176,G__G__Gui1_235_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i 'EButtonState' - 0 - state g - 'Bool_t' 0 'kFALSE' emit", (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("Class",502,G__G__Gui1_235_0_23, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGCheckButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_235_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCheckButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_235_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGCheckButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_235_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGCheckButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_235_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__Gui1_235_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCheckButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_235_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCheckButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_235_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCheckButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_235_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCheckButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGCheckButton", 1395, G__G__Gui1_235_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRadioButton(void) {
   /* TGRadioButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton));
   G__memfunc_setup("TGRadioButton",1286,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton), -1, 0, 1, 1, 4, 0, "u 'TGRadioButton' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton), -1, 1, 1, 1, 4, 0, "u 'TGRadioButton' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PSetState",893,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i 'EButtonState' - 0 - state g - 'Bool_t' 0 - emit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EmitSignals",1120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' wasUp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_236_0_7, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGRadioButton::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_236_0_8, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGRadioButton::GetDefaultGC) ), 0);
   G__memfunc_setup("TGRadioButton",1286,G__G__Gui1_236_0_9, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGHotString' - 0 - s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRadioButton",1286,G__G__Gui1_236_0_10, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p C - - 10 '0' s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRadioButton",1286,G__G__Gui1_236_0_11, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGRadioButton), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - s "
"C - - 10 - cmd i - 'Int_t' 0 '-1' id "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i 'EButtonState' - 0 - state g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDisabledAndSelected",2176,G__G__Gui1_236_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsToggleButton",1434,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsExclusiveToggle",1750,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOn",377,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDown",596,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDisabledAndSelected",2064,G__G__Gui1_236_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (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("Class",502,G__G__Gui1_236_0_24, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRadioButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_236_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRadioButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_236_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRadioButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_236_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRadioButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_236_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__Gui1_236_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRadioButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_236_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRadioButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_236_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRadioButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_236_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRadioButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGRadioButton", 1412, G__G__Gui1_236_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSplitButton(void) {
   /* TGSplitButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton));
   G__memfunc_setup("TGSplitButton",1315,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton), -1, 0, 1, 1, 4, 0, "u 'TGSplitButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton), -1, 1, 1, 1, 4, 0, "u 'TGSplitButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CalcSize",782,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawTriangle",1220,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"k - 'GContext_t' 10 - gc i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSButton",1307,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSCrossing",1511,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSKey",968,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMenuState",1218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BindKeys",793,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BindMenuKeys",1198,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGSplitButton",1315,G__G__Gui1_237_0_13, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGSplitButton), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGHotString' - 0 - menulabel "
"U 'TGPopupMenu' - 0 - popmenu g - 'Bool_t' 0 'kTRUE' split "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' fontstruct h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGHotString' - 0 - new_label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - new_label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fontName g - 'Bool_t' 0 'kFALSE' global", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMBState",956,G__G__Gui1_237_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EButtonState' - 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSplit",824,G__G__Gui1_237_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - split", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSplit",712,G__G__Gui1_237_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MBPressed",869,G__G__Gui1_237_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MBReleased",948,G__G__Gui1_237_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MBClicked",830,G__G__Gui1_237_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ItemClicked",1086,G__G__Gui1_237_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("HandleMenu",993,G__G__Gui1_237_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_237_0_32, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSplitButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_237_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_237_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSplitButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_237_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSplitButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_237_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_237_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_237_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_237_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_237_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSplitButton", 1441, G__G__Gui1_237_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextBuffer(void) {
   /* TGTextBuffer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer));
   G__memfunc_setup("TGTextBuffer",1178,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer), -1, 0, 1, 1, 2, 0, "u 'TGTextBuffer' - 11 - tb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer), -1, 1, 1, 1, 2, 0, "u 'TGTextBuffer' - 11 - tb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextBuffer",1178,G__G__Gui1_238_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextBuffer",1178,G__G__Gui1_238_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextLength",1319,G__G__Gui1_238_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufferLength",1500,G__G__Gui1_238_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetString",919,G__G__Gui1_238_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddText",686,G__G__Gui1_238_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - pos C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddText",686,G__G__Gui1_238_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - pos C - - 10 - text "
"i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveText",1043,G__G__Gui1_238_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - pos i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__G__Gui1_238_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_238_0_12, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextBuffer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_238_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextBuffer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_238_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextBuffer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_238_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextBuffer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_238_0_16, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_238_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__Gui1_238_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__Gui1_238_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__Gui1_238_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextBuffer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_238_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextBuffer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_238_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextBuffer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_238_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextBuffer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextBuffer", 1304, G__G__Gui1_238_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextEntry(void) {
   /* TGTextEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry));
   G__memfunc_setup("CopyText",832,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCharacterIndex",1701,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - xcoord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCursorOutOfFrame",1810,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paste",509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PastePrimary",1249,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"k - 'Window_t' 0 - wid k - 'Atom_t' 0 - property "
"g - 'Bool_t' 0 - del", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollByChar",1192,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateOffset",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSelectedGC",1944,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSelectedBackgroundGC",2968,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEntry",1106,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry), -1, 0, 1, 1, 4, 0, "u 'TGTextEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry), -1, 1, 1, 1, 4, 0, "u 'TGTextEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_240_0_14, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGTextEntry::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_240_0_15, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGTextEntry::GetDefaultGC) ), 0);
   G__memfunc_setup("TGTextEntry",1106,G__G__Gui1_240_0_16, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGTextBuffer' - 0 - text "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kSunkenFrame|kDoubleBorder' option "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEntry",1106,G__G__Gui1_240_0_17, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent C - - 10 '0' text "
"i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEntry",1106,G__G__Gui1_240_0_18, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntry), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - contents U 'TGWindow' - 10 - parent "
"i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultSize",1420,G__G__Gui1_240_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AppendText",1021,G__G__Gui1_240_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Backspace",893,G__G__Gui1_240_0_22, 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("CursorLeft",1033,G__G__Gui1_240_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' mark i - 'Int_t' 0 '1' steps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CursorRight",1148,G__G__Gui1_240_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' mark i - 'Int_t' 0 '1' steps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CursorWordForward",1775,G__G__Gui1_240_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' mark", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CursorWordBackward",1849,G__G__Gui1_240_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' mark", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cut",300,G__G__Gui1_240_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Del",277,G__G__Gui1_240_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Deselect",809,G__G__Gui1_240_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("End",279,G__G__Gui1_240_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' mark", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlignment",1215,G__G__Gui1_240_0_33, 105, G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuffer",890,G__G__Gui1_240_0_34, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGTextBuffer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCursorPosition",1779,G__G__Gui1_240_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDisplayText",1435,G__G__Gui1_240_0_36, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEchoMode",1060,G__G__Gui1_240_0_37, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEEchoMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInsertMode",1306,G__G__Gui1_240_0_38, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTextEntrycLcLEInsertMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarkedText",1305,G__G__Gui1_240_0_39, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxLength",1192,G__G__Gui1_240_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui1_240_0_41, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetToolTip",1003,G__G__Gui1_240_0_42, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGToolTip), -1, 0, 0, 1, 1, 8, "", (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("HasMarkedText",1301,G__G__Gui1_240_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextColor",1220,G__G__Gui1_240_0_45, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui1_240_0_46, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Home",393,G__G__Gui1_240_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' mark", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,G__G__Gui1_240_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertText",1050,G__G__Gui1_240_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFrameDrawn",1187,G__G__Gui1_240_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEdited",779,G__G__Gui1_240_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MarkWord",807,G__G__Gui1_240_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MaxMark",689,G__G__Gui1_240_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinMark",687,G__G__Gui1_240_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewMark",693,G__G__Gui1_240_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Gui1_240_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveText",1043,G__G__Gui1_240_0_58, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - start i - 'Int_t' 0 - end", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui1_240_0_59, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFont' - 0 - font g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui1_240_0_60, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'FontStruct_t' 0 - font g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui1_240_0_61, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fontName g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_240_0_62, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Pixel_t' 0 - color g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_240_0_63, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TColor' - 0 - color g - 'Bool_t' 0 'kTRUE' local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui1_240_0_64, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text g - 'Bool_t' 0 'kTRUE' emit", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetToolTipText",1436,G__G__Gui1_240_0_65, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text l - 'Long_t' 0 '500' delayms", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMaxLength",1204,G__G__Gui1_240_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxlen", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SelectAll",889,G__G__Gui1_240_0_67, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlignment",1227,G__G__Gui1_240_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ETextJustification' - 0 'kTextLeft' mode", "*SUBMENU*", (void*) NULL, 1);
   G__memfunc_setup("SetInsertMode",1318,G__G__Gui1_240_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGTextEntry::EInsertMode' - 0 'kInsert' mode", "*SUBMENU*", (void*) NULL, 1);
   G__memfunc_setup("SetEchoMode",1072,G__G__Gui1_240_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGTextEntry::EEchoMode' - 0 'kNormal' mode", "*SUBMENU*", (void*) NULL, 1);
   G__memfunc_setup("SetEnabled",983,G__G__Gui1_240_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsEnabled", (void*) NULL, 0);
   G__memfunc_setup("SetCursorPosition",1791,G__G__Gui1_240_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEdited",891,G__G__Gui1_240_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFocus",812,G__G__Gui1_240_0_74, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFrameDrawn",1299,G__G__Gui1_240_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,G__G__Gui1_240_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Gui1_240_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetForegroundColor",1862,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - fore", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetForeground",1339,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasOwnFont",999,G__G__Gui1_240_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDoubleClick",1677,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleFocusChange",1682,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelection",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionClear",2009,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleSelectionRequest",2267,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleConfigureNotify",2151,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TextChanged",1103,G__G__Gui1_240_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' text", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,G__G__Gui1_240_0_94, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("TabPressed",1005,G__G__Gui1_240_0_95, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ShiftTabPressed",1515,G__G__Gui1_240_0_96, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CursorOutLeft",1345,G__G__Gui1_240_0_97, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CursorOutRight",1460,G__G__Gui1_240_0_98, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CursorOutUp",1147,G__G__Gui1_240_0_99, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CursorOutDown",1358,G__G__Gui1_240_0_100, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui1_240_0_101, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_240_0_102, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_240_0_103, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_240_0_104, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_240_0_105, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_240_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_240_0_110, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_240_0_111, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_240_0_112, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_240_0_113, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextEntry", 1232, G__G__Gui1_240_0_114, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMsgBox(void) {
   /* TGMsgBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox));
   G__memfunc_setup("PMsgBox",672,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"C - - 10 - title C - - 10 - msg "
"U 'TGPicture' - 10 - icon i - 'Int_t' 0 - buttons "
"I - 'Int_t' 0 - ret_code i - 'Int_t' 0 - text_align", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMsgBox",747,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox), -1, 0, 1, 1, 4, 0, "u 'TGMsgBox' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox), -1, 1, 1, 1, 4, 0, "u 'TGMsgBox' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGMsgBox",747,G__G__Gui1_245_0_4, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGWindow' - 10 '0' main "
"C - - 10 '0' title C - - 10 '0' msg "
"U 'TGPicture' - 10 '0' icon i - 'Int_t' 0 'kMBDismiss' buttons "
"I - 'Int_t' 0 '0' ret_code h - 'UInt_t' 0 'kVerticalFrame' options "
"i - 'Int_t' 0 'kTextCenterX|kTextCenterY' text_align", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMsgBox",747,G__G__Gui1_245_0_5, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMsgBox), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGWindow' - 10 - main "
"C - - 10 - title C - - 10 - msg "
"i 'EMsgBoxIcon' - 0 - icon i - 'Int_t' 0 'kMBDismiss' buttons "
"I - 'Int_t' 0 '0' ret_code h - 'UInt_t' 0 'kVerticalFrame' options "
"i - 'Int_t' 0 'kTextCenterX|kTextCenterY' text_align", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_245_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMsgBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_245_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMsgBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_245_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMsgBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_245_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMsgBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_245_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__Gui1_245_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMsgBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_245_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMsgBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_245_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMsgBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_245_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMsgBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMsgBox", 873, G__G__Gui1_245_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMenuBar(void) {
   /* TGMenuBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar));
   G__memfunc_setup("AddFrameBefore",1351,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l "
"U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BindHotKey",977,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - keycode g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BindKeys",793,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BindMenu",786,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGPopupMenu' - 0 - subMenu g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMenuBar",837,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar), -1, 0, 1, 1, 4, 0, "u 'TGMenuBar' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar), -1, 1, 1, 1, 4, 0, "u 'TGMenuBar' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGMenuBar",837,G__G__Gui1_248_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuBar), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '60' w "
"h - 'UInt_t' 0 '20' h h - 'UInt_t' 0 'kHorizontalFrame|kRaisedFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPopup",797,G__G__Gui1_248_0_8, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGHotString' - 0 - s U 'TGPopupMenu' - 0 - menu "
"U 'TGLayoutHints' - 0 - l U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddPopup",797,G__G__Gui1_248_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - s U 'TGPopupMenu' - 0 - menu "
"U 'TGLayoutHints' - 0 - l U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddPopup",797,G__G__Gui1_248_0_10, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - s i - 'Int_t' 0 '4' padleft "
"i - 'Int_t' 0 '0' padright i - 'Int_t' 0 '0' padtop "
"i - 'Int_t' 0 '0' padbottom", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTitle",779,G__G__Gui1_248_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGMenuTitle' - 0 - title U 'TGLayoutHints' - 0 - l "
"U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPopup",820,G__G__Gui1_248_0_12, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemovePopup",1154,G__G__Gui1_248_0_13, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrent",1027,G__G__Gui1_248_0_14, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitles",917,G__G__Gui1_248_0_15, 85, G__get_linked_tagnum(&G__G__Gui1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (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("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopupConnection",1572,G__G__Gui1_248_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastOnLeft",1276,G__G__Gui1_248_0_22, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_248_0_23, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMenuBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_248_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_248_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMenuBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_248_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMenuBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_248_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__Gui1_248_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_248_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMenuBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_248_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_248_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMenuBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMenuBar", 963, G__G__Gui1_248_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMenuTitle(void) {
   /* TGMenuTitle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGMenuTitle",1074,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle), -1, 0, 1, 1, 4, 0, "u 'TGMenuTitle' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle), -1, 1, 1, 1, 4, 0, "u 'TGMenuTitle' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_249_0_4, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGMenuTitle::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultSelectedGC",1944,G__G__Gui1_249_0_5, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGMenuTitle::GetDefaultSelectedGC) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_249_0_6, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGMenuTitle::GetDefaultGC) ), 0);
   G__memfunc_setup("TGMenuTitle",1074,G__G__Gui1_249_0_7, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuTitle), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGHotString' - 0 '0' s "
"U 'TGPopupMenu' - 0 '0' menu k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextColor",1220,G__G__Gui1_249_0_8, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextColor",1232,G__G__Gui1_249_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetState",813,G__G__Gui1_249_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetState",801,G__G__Gui1_249_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHotKeyCode",1263,G__G__Gui1_249_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenu",693,G__G__Gui1_249_0_13, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 0, 1, 1, 8, "", (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("DoSendMessage",1282,G__G__Gui1_249_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (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("Class",502,G__G__Gui1_249_0_17, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMenuTitle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_249_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuTitle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_249_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMenuTitle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_249_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMenuTitle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_249_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__Gui1_249_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuTitle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_249_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMenuTitle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_249_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuTitle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_249_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMenuTitle::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMenuTitle", 1200, G__G__Gui1_249_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMenuEntry(void) {
   /* TGMenuEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry));
   G__memfunc_setup("TGMenuEntry",1090,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry), -1, 0, 1, 1, 4, 0, "u 'TGMenuEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry), -1, 1, 1, 1, 4, 0, "u 'TGMenuEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGMenuEntry",1090,G__G__Gui1_250_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGMenuEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryId",991,G__G__Gui1_250_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("GetShortcutText",1569,G__G__Gui1_250_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__G__Gui1_250_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Gui1_250_0_8, 105, G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPopup",820,G__G__Gui1_250_0_9, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPopupMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabel",768,G__G__Gui1_250_0_10, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGHotString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShortcut",1148,G__G__Gui1_250_0_11, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEx",477,G__G__Gui1_250_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEy",478,G__G__Gui1_250_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEw",476,G__G__Gui1_250_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEh",461,G__G__Gui1_250_0_15, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPic",572,G__G__Gui1_250_0_16, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserData",1081,G__G__Gui1_250_0_17, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_250_0_18, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMenuEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_250_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_250_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMenuEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_250_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMenuEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_250_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__Gui1_250_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_250_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMenuEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_250_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMenuEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_250_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMenuEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMenuEntry", 1216, G__G__Gui1_250_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGShutterItem(void) {
   /* TGShutterItem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem));
   G__memfunc_setup("TGShutterItem",1305,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem), -1, 0, 1, 1, 4, 0, "u 'TGShutterItem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem), -1, 1, 1, 1, 4, 0, "u 'TGShutterItem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGShutterItem",1305,G__G__Gui1_261_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGHotString' - 0 '0' s "
"i - 'Int_t' 0 '-1' id h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetButton",924,G__G__Gui1_261_0_4, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContainer",1219,G__G__Gui1_261_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Selected",809,G__G__Gui1_261_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (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("Class",502,G__G__Gui1_261_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGShutterItem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_261_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShutterItem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_261_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGShutterItem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_261_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGShutterItem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_261_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__Gui1_261_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShutterItem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_261_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGShutterItem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_261_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShutterItem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_261_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGShutterItem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGShutterItem", 1431, G__G__Gui1_261_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGShutter(void) {
   /* TGShutter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGShutter));
   G__memfunc_setup("TGShutter",906,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGShutter), -1, 0, 1, 1, 4, 0, "u 'TGShutter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGShutter), -1, 1, 1, 1, 4, 0, "u 'TGShutter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGShutter",906,G__G__Gui1_262_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGShutter), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 'kSunkenFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddItem",664,G__G__Gui1_262_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGShutterItem' - 0 - item", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveItem",1021,G__G__Gui1_262_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddPage",646,G__G__Gui1_262_0_6, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem), -1, 0, 1, 1, 1, 0, "C - - 10 '\"Page\"' item", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemovePage",1003,G__G__Gui1_262_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RenamePage",981,G__G__Gui1_262_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TTimer' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLayoutManager",1637,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLayoutManager' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedItem",1496,G__G__Gui1_262_0_12, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetItem",687,G__G__Gui1_262_0_13, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGShutterItem), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelectedItem",1508,G__G__Gui1_262_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGShutterItem' - 0 - item", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelectedItem",1508,G__G__Gui1_262_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableItem",982,G__G__Gui1_262_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultSize",1420,G__G__Gui1_262_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (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("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - cmd l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui1_262_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGShutterItem' - 0 - item", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_262_0_22, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGShutter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_262_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShutter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_262_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGShutter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_262_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGShutter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_262_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_262_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShutter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_262_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGShutter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_262_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGShutter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_262_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGShutter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGShutter", 1032, G__G__Gui1_262_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHorizontal3DLine(void) {
   /* TGHorizontal3DLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine));
   G__memfunc_setup("TGHorizontal3DLine",1732,G__G__Gui1_263_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHorizontal3DLine), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '4' w "
"h - 'UInt_t' 0 '2' h h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("Class",502,G__G__Gui1_263_0_4, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHorizontal3DLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_263_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontal3DLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_263_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHorizontal3DLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_263_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHorizontal3DLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_263_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__Gui1_263_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontal3DLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_263_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHorizontal3DLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_263_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHorizontal3DLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_263_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHorizontal3DLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHorizontal3DLine", 1858, G__G__Gui1_263_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVertical3DLine(void) {
   /* TGVertical3DLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine));
   G__memfunc_setup("TGVertical3DLine",1492,G__G__Gui1_264_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVertical3DLine), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '2' w "
"h - 'UInt_t' 0 '4' h h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("Class",502,G__G__Gui1_264_0_4, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVertical3DLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_264_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVertical3DLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_264_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVertical3DLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_264_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVertical3DLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_264_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__Gui1_264_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVertical3DLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_264_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVertical3DLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_264_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVertical3DLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_264_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVertical3DLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVertical3DLine", 1618, G__G__Gui1_264_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGProgressBar(void) {
   /* TGProgressBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBar));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui1_265_0_2, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGProgressBar::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui1_265_0_3, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGProgressBar::GetDefaultGC) ), 0);
   G__memfunc_setup("GetMin",580,G__G__Gui1_265_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMax",582,G__G__Gui1_265_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__G__Gui1_265_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFillType",1097,G__G__Gui1_265_0_8, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEFillType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBarType",983,G__G__Gui1_265_0_9, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGProgressBarcLcLEBarType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowPos",1011,G__G__Gui1_265_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFormat",905,G__G__Gui1_265_0_11, 117, G__get_linked_tagnum(&G__G__Gui1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueFormat",1414,G__G__Gui1_265_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsePercent",1022,G__G__Gui1_265_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBarColor",1076,G__G__Gui1_265_0_14, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormGC",838,G__G__Gui1_265_0_15, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui1_265_0_16, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__G__Gui1_265_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - pos", "*MENU*  *GETTER=GetPosition", (void*) NULL, 0);
   G__memfunc_setup("SetRange",793,G__G__Gui1_265_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Increment",933,G__G__Gui1_265_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - inc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBarType",995,G__G__Gui1_265_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGProgressBar::EBarType' - 0 - type", "*SUBMENU*", (void*) NULL, 0);
   G__memfunc_setup("SetFillType",1109,G__G__Gui1_265_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGProgressBar::EFillType' - 0 - type", "*SUBMENU*", (void*) NULL, 0);
   G__memfunc_setup("Percent",721,G__G__Gui1_265_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", "*TOGGLE* *GETTER=UsePercent", (void*) NULL, 1);
   G__memfunc_setup("ShowPos",723,G__G__Gui1_265_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", "*TOGGLE* *GETTER=GetShowPos", (void*) NULL, 1);
   G__memfunc_setup("Format",617,G__G__Gui1_265_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"%.2f\"' format", "*MENU* *GETTER=GetValueFormat", (void*) NULL, 1);
   G__memfunc_setup("SetMin",592,G__G__Gui1_265_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMax",594,G__G__Gui1_265_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBarColor",1088,G__G__Gui1_265_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBarColor",1088,G__G__Gui1_265_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"blue\"' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Gui1_265_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetForegroundColor",1862,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pixel", (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("Class",502,G__G__Gui1_265_0_32, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGProgressBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_265_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGProgressBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_265_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGProgressBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_265_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGProgressBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_265_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_265_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGProgressBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_265_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGProgressBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_265_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGProgressBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_265_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGProgressBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGProgressBar", 1411, G__G__Gui1_265_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHProgressBar(void) {
   /* TGHProgressBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGHProgressBar",1357,G__G__Gui1_269_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '4' w "
"h - 'UInt_t' 0 'kProgressBarTextWidth' h k - 'Pixel_t' 0 'GetWhitePixel()' back "
"k - 'Pixel_t' 0 'GetDefaultSelectedBackground()' barcolor k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kDoubleBorder|kSunkenFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGHProgressBar",1357,G__G__Gui1_269_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHProgressBar), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p i 'TGProgressBar::EBarType' - 0 - type "
"h - 'UInt_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowPosition",1270,G__G__Gui1_269_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' set g - 'Bool_t' 0 'kTRUE' percent "
"C - - 10 '\"%.2f\"' format", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_269_0_7, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHProgressBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_269_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHProgressBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_269_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHProgressBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_269_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHProgressBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_269_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_269_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHProgressBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_269_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHProgressBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_269_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHProgressBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_269_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHProgressBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHProgressBar", 1483, G__G__Gui1_269_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVProgressBar(void) {
   /* TGVProgressBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGVProgressBar",1371,G__G__Gui1_270_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 'kProgressBarTextWidth' w "
"h - 'UInt_t' 0 '4' h k - 'Pixel_t' 0 'GetWhitePixel()' back "
"k - 'Pixel_t' 0 'GetDefaultSelectedBackground()' barcolor k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kDoubleBorder|kSunkenFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGVProgressBar",1371,G__G__Gui1_270_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVProgressBar), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - p i 'TGProgressBar::EBarType' - 0 - type "
"h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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("ShowPos",723,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Percent",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_270_0_8, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVProgressBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_270_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVProgressBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_270_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVProgressBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_270_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVProgressBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_270_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__Gui1_270_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVProgressBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_270_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVProgressBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_270_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVProgressBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_270_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVProgressBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVProgressBar", 1497, G__G__Gui1_270_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVButtonGroup(void) {
   /* TGVButtonGroup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup));
   G__memfunc_setup("TGVButtonGroup",1402,G__G__Gui1_276_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGVButtonGroup), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - parent u 'TString' - 11 '\"\"' title "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_276_0_3, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVButtonGroup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_276_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVButtonGroup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_276_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVButtonGroup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_276_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVButtonGroup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_276_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_276_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVButtonGroup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_276_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVButtonGroup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_276_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVButtonGroup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_276_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVButtonGroup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVButtonGroup", 1528, G__G__Gui1_276_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHButtonGroup(void) {
   /* TGHButtonGroup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup));
   G__memfunc_setup("TGHButtonGroup",1388,G__G__Gui1_277_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGHButtonGroup), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - parent u 'TString' - 11 '\"\"' title "
"k - 'GContext_t' 0 'GetDefaultGC()()' norm k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui1_277_0_3, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHButtonGroup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_277_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHButtonGroup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_277_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHButtonGroup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_277_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHButtonGroup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_277_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_277_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHButtonGroup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_277_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHButtonGroup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_277_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHButtonGroup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_277_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHButtonGroup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHButtonGroup", 1514, G__G__Gui1_277_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGNumberFormat(void) {
   /* TGNumberFormat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat));
   G__memfunc_setup("Class",502,G__G__Gui1_278_0_1, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGNumberFormat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_278_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberFormat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_278_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGNumberFormat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_278_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGNumberFormat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui1_278_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui1_278_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui1_278_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui1_278_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_278_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberFormat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_278_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberFormat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_278_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberFormat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_278_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberFormat::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TGNumberFormat", 1389, G__G__Gui1_278_0_13, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TGNumberFormat", 1389, G__G__Gui1_278_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat), -1, 0, 1, 1, 1, 0, "u 'TGNumberFormat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGNumberFormat", 1515, G__G__Gui1_278_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__Gui1_278_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormat), -1, 1, 1, 1, 1, 0, "u 'TGNumberFormat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGNumberEntryField(void) {
   /* TGNumberEntryField */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField));
   G__memfunc_setup("TGNumberEntryField",1786,G__G__Gui1_283_0_1, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - p i - 'Int_t' 0 - id "
"d - 'Double_t' 0 - val k - 'GContext_t' 0 - norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kSunkenFrame|kDoubleBorder' option "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGNumberEntryField",1786,G__G__Gui1_283_0_2, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent i - 'Int_t' 0 '-1' id "
"d - 'Double_t' 0 '0' val i 'TGNumberFormat::EStyle' - 0 'kNESReal' style "
"i 'TGNumberFormat::EAttribute' - 0 'kNEAAnyNumber' attr i 'TGNumberFormat::ELimit' - 0 'kNELNoLimits' limits "
"d - 'Double_t' 0 '0' min d - 'Double_t' 0 '1' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumber",917,G__G__Gui1_283_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIntNumber",1216,G__G__Gui1_283_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTime",699,G__G__Gui1_283_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - hour i - 'Int_t' 0 - min "
"i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDate",682,G__G__Gui1_283_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - year i - 'Int_t' 0 - month "
"i - 'Int_t' 0 - day", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHexNumber",1210,G__G__Gui1_283_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumber",905,G__G__Gui1_283_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntNumber",1204,G__G__Gui1_283_0_10, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTime",687,G__G__Gui1_283_0_11, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - hour i - 'Int_t' 1 - min "
"i - 'Int_t' 1 - sec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDate",670,G__G__Gui1_283_0_12, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - year i - 'Int_t' 1 - month "
"i - 'Int_t' 1 - day", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHexNumber",1198,G__G__Gui1_283_0_13, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCharWidth",1182,G__G__Gui1_283_0_14, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 '\"0\"' text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IncreaseNumber",1427,G__G__Gui1_283_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TGNumberFormat::EStepSize' - 0 'kNSSSmall' step i - 'Int_t' 0 '1' sign "
"g - 'Bool_t' 0 'kFALSE' logstep", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFormat",917,G__G__Gui1_283_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'TGNumberFormat::EStyle' - 0 - style i 'TGNumberFormat::EAttribute' - 0 'kNEAAnyNumber' attr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimits",926,G__G__Gui1_283_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TGNumberFormat::ELimit' - 0 'kNELNoLimits' limits d - 'Double_t' 0 '0' min "
"d - 'Double_t' 0 '1' max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLogStep",1002,G__G__Gui1_283_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumStyle",1121,G__G__Gui1_283_0_20, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumAttr",1003,G__G__Gui1_283_0_21, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumLimits",1218,G__G__Gui1_283_0_22, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumMin",884,G__G__Gui1_283_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumMax",886,G__G__Gui1_283_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLogStep",890,G__G__Gui1_283_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleFocusChange",1682,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TextChanged",1103,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEditable",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvalidInput",1239,G__G__Gui1_283_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - instr", "*SIGNAL*", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_283_0_34, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGNumberEntryField::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_283_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntryField::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_283_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGNumberEntryField::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_283_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGNumberEntryField::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_283_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_283_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntryField::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_283_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberEntryField::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_283_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntryField::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_283_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberEntryField::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGNumberEntryField", 1912, G__G__Gui1_283_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGNumberEntry(void) {
   /* TGNumberEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry));
   G__memfunc_setup("TGNumberEntry",1302,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry), -1, 0, 1, 1, 4, 0, "u 'TGNumberEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry), -1, 1, 1, 1, 4, 0, "u 'TGNumberEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGNumberEntry",1302,G__G__Gui1_284_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntry), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent d - 'Double_t' 0 '0' val "
"i - 'Int_t' 0 '5' digitwidth i - 'Int_t' 0 '-1' id "
"i 'TGNumberFormat::EStyle' - 0 'kNESReal' style i 'TGNumberFormat::EAttribute' - 0 'kNEAAnyNumber' attr "
"i 'TGNumberFormat::ELimit' - 0 'kNELNoLimits' limits d - 'Double_t' 0 '0' min "
"d - 'Double_t' 0 '1' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumber",917,G__G__Gui1_284_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIntNumber",1216,G__G__Gui1_284_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTime",699,G__G__Gui1_284_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - hour i - 'Int_t' 0 - min "
"i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDate",682,G__G__Gui1_284_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - year i - 'Int_t' 0 - month "
"i - 'Int_t' 0 - day", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHexNumber",1210,G__G__Gui1_284_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui1_284_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetState",813,G__G__Gui1_284_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumber",905,G__G__Gui1_284_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntNumber",1204,G__G__Gui1_284_0_12, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTime",687,G__G__Gui1_284_0_13, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - hour i - 'Int_t' 1 - min "
"i - 'Int_t' 1 - sec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDate",670,G__G__Gui1_284_0_14, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - year i - 'Int_t' 1 - month "
"i - 'Int_t' 1 - day", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHexNumber",1198,G__G__Gui1_284_0_15, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IncreaseNumber",1427,G__G__Gui1_284_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TGNumberFormat::EStepSize' - 0 'kNSSSmall' step i - 'Int_t' 0 '1' sign "
"g - 'Bool_t' 0 'kFALSE' logstep", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFormat",917,G__G__Gui1_284_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'TGNumberFormat::EStyle' - 0 - style i 'TGNumberFormat::EAttribute' - 0 'TGNumberFormat::kNEAAnyNumber' attr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimits",926,G__G__Gui1_284_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TGNumberFormat::ELimit' - 0 'TGNumberFormat::kNELNoLimits' limits d - 'Double_t' 0 '0' min "
"d - 'Double_t' 0 '1' max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumStyle",1121,G__G__Gui1_284_0_19, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEStyle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumAttr",1003,G__G__Gui1_284_0_20, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumLimits",1218,G__G__Gui1_284_0_21, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberFormatcLcLELimit), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumMin",884,G__G__Gui1_284_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumMax",886,G__G__Gui1_284_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLogStep",890,G__G__Gui1_284_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetButtonToNum",1435,G__G__Gui1_284_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumStyle",1133,G__G__Gui1_284_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGNumberFormat::EStyle' - 0 - style", "*SUBMENU*", (void*) NULL, 0);
   G__memfunc_setup("SetNumAttr",1015,G__G__Gui1_284_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGNumberFormat::EAttribute' - 0 'kNEAAnyNumber' attr", "*SUBMENU*", (void*) NULL, 0);
   G__memfunc_setup("SetNumLimits",1230,G__G__Gui1_284_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGNumberFormat::ELimit' - 0 'kNELNoLimits' limits", "*SUBMENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLimitValues",1435,G__G__Gui1_284_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0' min d - 'Double_t' 0 '1' max", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLogStep",1002,G__G__Gui1_284_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "*TOGGLE* *GETTER=IsLogStep", (void*) NULL, 1);
   G__memfunc_setup("Associate",924,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ValueChanged",1191,G__G__Gui1_284_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ValueSet",809,G__G__Gui1_284_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetNumberEntry",1435,G__G__Gui1_284_0_35, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryField), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetButtonUp",1121,G__G__Gui1_284_0_36, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetButtonDown",1332,G__G__Gui1_284_0_37, 85, G__get_linked_tagnum(&G__G__Gui1LN_TGButton), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEditable",982,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultHeight",1598,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLayoutManager",1625,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_TGLayoutManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_284_0_42, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGNumberEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_284_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_284_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGNumberEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_284_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGNumberEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_284_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__Gui1_284_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_284_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_284_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_284_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGNumberEntry", 1428, G__G__Gui1_284_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGNumberEntryLayout(void) {
   /* TGNumberEntryLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout));
   G__memfunc_setup("TGNumberEntryLayout",1940,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout), -1, 0, 1, 1, 4, 0, "u 'TGNumberEntryLayout' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout), -1, 1, 1, 1, 4, 0, "u 'TGNumberEntryLayout' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGNumberEntryLayout",1940,G__G__Gui1_285_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGNumberEntryLayout), -1, 0, 1, 1, 1, 0, "U 'TGNumberEntry' - 0 - box", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_285_0_6, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGNumberEntryLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_285_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntryLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_285_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGNumberEntryLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_285_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGNumberEntryLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_285_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__Gui1_285_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntryLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_285_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberEntryLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_285_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGNumberEntryLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_285_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGNumberEntryLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGNumberEntryLayout", 2066, G__G__Gui1_285_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTableLayoutHints(void) {
   /* TGTableLayoutHints */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints));
   G__memfunc_setup("TGTableLayoutHints",1799,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints), -1, 0, 1, 1, 4, 0, "u 'TGTableLayoutHints' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints), -1, 1, 1, 1, 4, 0, "u 'TGTableLayoutHints' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGTableLayoutHints",1799,G__G__Gui1_287_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayoutHints), -1, 0, 9, 1, 1, 0, 
"h - 'UInt_t' 0 - attach_left h - 'UInt_t' 0 - attach_right "
"h - 'UInt_t' 0 - attach_top h - 'UInt_t' 0 - attach_bottom "
"k - 'ULong_t' 0 'kLHintsNormal' hints h - 'UInt_t' 0 '0' padleft "
"h - 'UInt_t' 0 '0' padright h - 'UInt_t' 0 '0' padtop "
"h - 'UInt_t' 0 '0' padbottom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttachLeft",1280,G__G__Gui1_287_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttachRight",1395,G__G__Gui1_287_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttachTop",1192,G__G__Gui1_287_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttachBottom",1514,G__G__Gui1_287_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_287_0_9, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTableLayoutHints::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_287_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableLayoutHints::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_287_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTableLayoutHints::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_287_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTableLayoutHints::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_287_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_287_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableLayoutHints::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_287_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableLayoutHints::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_287_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableLayoutHints::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_287_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableLayoutHints::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTableLayoutHints", 1925, G__G__Gui1_287_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTableLayout(void) {
   /* TGTableLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout));
   G__memfunc_setup("TGTableLayout",1281,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout), -1, 0, 1, 1, 4, 0, "u 'TGTableLayout' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout), -1, 1, 1, 1, 4, 0, "u 'TGTableLayout' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("FindRowColSizes",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRowColSizesInit",1913,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRowColSizesHomogeneous",2670,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRowColSizesSinglyAttached",2937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindRowColSizesMultiplyAttached",3171,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRowColSizes",1424,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRowColSizesInit",1828,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSanity",1110,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRowColResize",1524,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"h - 'UInt_t' 0 - real_size h - 'UInt_t' 0 - nthings "
"U 'TGTableLayout::TableData_t' - 0 - thing g - 'Bool_t' 0 - homogeneous", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTableLayout",1281,G__G__Gui1_288_0_12, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGTableLayout), -1, 0, 6, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - main h - 'UInt_t' 0 - nrows "
"h - 'UInt_t' 0 - ncols g - 'Bool_t' 0 'kFALSE' homogeneous "
"i - 'Int_t' 0 '0' sep i - 'Int_t' 0 '0' hints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui1LN_TGDimension), -1, 0, 0, 1, 1, 8, "", "return sum of all child sizes", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_288_0_16, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTableLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_288_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_288_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTableLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_288_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTableLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_288_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__Gui1_288_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_288_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_288_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTableLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_288_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTableLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTableLayout", 1407, G__G__Gui1_288_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGInputDialog(void) {
   /* TGInputDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog));
   G__memfunc_setup("TGInputDialog",1275,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog), -1, 0, 1, 1, 4, 0, "u 'TGInputDialog' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog), -1, 1, 1, 1, 4, 0, "u 'TGInputDialog' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGInputDialog",1275,G__G__Gui1_290_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGInputDialog), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGWindow' - 10 '0' main "
"C - - 10 '0' prompt C - - 10 '0' defval "
"C - - 0 '0' retstr h - 'UInt_t' 0 'kVerticalFrame' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui1_290_0_5, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGInputDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_290_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGInputDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_290_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGInputDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_290_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGInputDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_290_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_290_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGInputDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_290_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGInputDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_290_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGInputDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_290_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGInputDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGInputDialog", 1401, G__G__Gui1_290_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFrameElementPack(void) {
   /* TGFrameElementPack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack));
   G__memfunc_setup("TGFrameElementPack",1743,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack), -1, 0, 1, 1, 4, 0, "u 'TGFrameElementPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack), -1, 1, 1, 1, 4, 0, "u 'TGFrameElementPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGFrameElementPack",1743,G__G__Gui1_292_0_3, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGFrameElementPack), -1, 0, 3, 1, 1, 0, 
"U 'TGFrame' - 0 - frame U 'TGLayoutHints' - 0 '0' lh "
"f - 'Float_t' 0 '1' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_292_0_4, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFrameElementPack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_292_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrameElementPack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_292_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFrameElementPack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_292_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFrameElementPack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_292_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__Gui1_292_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrameElementPack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_292_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFrameElementPack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_292_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFrameElementPack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_292_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFrameElementPack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFrameElementPack", 1869, G__G__Gui1_292_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPack(void) {
   /* TGPack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui1LN_TGPack));
   G__memfunc_setup("TGPack",538,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPack), -1, 0, 1, 1, 4, 0, "u 'TGPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui1LN_TGPack), -1, 1, 1, 1, 4, 0, "u 'TGPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetFrameLength",1389,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "U 'TGFrame' - 10 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLength",898,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAvailableLength",1795,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameLength",1401,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGFrame' - 0 - f i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFramePosition",1644,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGFrame' - 0 - f i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindFrames",991,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"U 'TGFrame' - 0 - splitter U 'TGFrameElementPack' - 1 - f0 "
"U 'TGFrameElementPack' - 1 - f1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSplitterVisibility",2397,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeExistingFrames",2075,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefitFramesToPack",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFrameInternal",1585,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l "
"f - 'Float_t' 0 '1' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveFrameInternal",1942,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPack",538,G__G__Gui1_293_0_14, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPack), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGPack",538,G__G__Gui1_293_0_15, 105, G__get_linked_tagnum(&G__G__Gui1LN_TGPack), -1, 0, 3, 1, 1, 0, 
"U 'TGClient' - 0 - c k - 'Window_t' 0 - id "
"U 'TGWindow' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFrameWithWeight",1784,G__G__Gui1_293_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 - l "
"f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFrame",756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteFrame",1086,G__G__Gui1_293_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFrame",1113,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowFrame",908,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HideFrame",869,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapSubwindows",1363,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MoveResize",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 '0' w h - 'UInt_t' 0 '0' h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("EqualizeFrames",1438,G__G__Gui1_293_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSplitterStart",1969,G__G__Gui1_293_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleSplitterResize",2069,G__G__Gui1_293_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertical",1114,G__G__Gui1_293_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertical",1126,G__G__Gui1_293_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseSplitters",1559,G__G__Gui1_293_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseSplitters",1571,G__G__Gui1_293_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui1_293_0_34, 85, G__get_linked_tagnum(&G__G__Gui1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui1_293_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui1_293_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui1_293_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui1LN_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__Gui1_293_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui1_293_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui1_293_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui1_293_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui1_293_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGPack", 664, G__G__Gui1_293_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Gui1() {
}

/*********************************************************
* 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() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
   G__memvar_setup((void*)(&gClient),85,0,0,G__get_linked_tagnum(&G__G__Gui1LN_TGClient),-1,-1,1,"gClient=",0,(char*)NULL);
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsNoHints=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsLeft=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsCenterX=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsRight=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsTop=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsCenterY=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsBottom=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsExpandX=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsExpandY=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ELayoutHints),-1,-1,1,"kLHintsNormal=9",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameState),-1,-1,1,"kIsVisible=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameState),-1,-1,1,"kIsMapped=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameState),-1,-1,1,"kIsArranged=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameCleanup),-1,-1,1,"kNoCleanup=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameCleanup),-1,-1,1,"kLocalCleanup=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameCleanup),-1,-1,1,"kDeepCleanup=-1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kChildFrame=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kMainFrame=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kVerticalFrame=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kHorizontalFrame=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kSunkenFrame=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kRaisedFrame=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kDoubleBorder=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kFitWidth=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kFixedWidth=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kFitHeight=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kFixedHeight=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kFixedSize=640",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kOwnBackground=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kTransientFrame=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kTempFrame=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kMdiMainFrame=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EFrameType),-1,-1,1,"kMdiFrame=16384",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMFuncAll=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMFuncResize=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMFuncMove=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMFuncMinimize=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMFuncMaximize=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMFuncClose=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMInputModeless=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMInputPrimaryApplicationModal=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMInputSystemModal=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMInputFullApplicationModal=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorAll=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorBorder=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorResizeH=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorTitle=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorMenu=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorMinimize=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMWMHints),-1,-1,1,"kMWMDecorMaximize=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_COMMAND=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_MENU=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_MENUSELECT=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_BUTTON=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_CHECKBUTTON=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_RADIOBUTTON=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_LISTBOX=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_COMBOBOX=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCM_TAB=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_HSCROLL=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_VSCROLL=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSB_LINEUP=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSB_LINEDOWN=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSB_PAGEUP=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSB_PAGEDOWN=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSB_SLIDERTRACK=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSB_SLIDERPOS=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_TEXTENTRY=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTE_TEXTCHANGED=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTE_ENTER=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTE_TAB=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTE_KEY=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_CONTAINER=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCT_ITEMCLICK=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCT_ITEMDBLCLICK=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCT_SELCHANGED=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCT_KEY=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_HSLIDER=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_VSLIDER=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSL_POS=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSL_TRACK=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSL_PRESS=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSL_RELEASE=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kSL_POINTER=5",0,(char*)NULL);
}

static void G__cpp_setup_global5() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_LISTTREE=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_TEXTVIEW=9",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_ISMARKED=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_DATACHANGE=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_CLICK2=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_CLICK3=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_F3=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_OPEN=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_CLOSE=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kTXT_SAVE=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_COLORSEL=10",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCOL_CLICK=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kCOL_SELCHANGED=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_PATTERNSEL=11",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kPAT_CLICK=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kPAT_SELCHANGED=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_MARKERSEL=12",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMAR_CLICK=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMAR_SELCHANGED=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_POPUP=13",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kPOP_HIDE=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_DOCK=14",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kDOCK_DOCK=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kDOCK_UNDOCK=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kDOCK_SHOW=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kDOCK_HIDE=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_MDI=15",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_CURRENT=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_CREATE=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_CLOSE=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_RESTORE=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_MOVE=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_SIZE=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_MINIMIZE=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_MAXIMIZE=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_HELP=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kMDI_MENU=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_USER=1001",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetMessageTypes),-1,-1,1,"kC_MSGMAX=10000",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,1,"kTextLeft=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,1,"kTextRight=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,1,"kTextCenterX=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,1,"kTextTop=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,1,"kTextBottom=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETextJustification),-1,-1,1,"kTextCenterY=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetStatus),-1,-1,1,"kWidgetWantFocus=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetStatus),-1,-1,1,"kWidgetHasFocus=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EWidgetStatus),-1,-1,1,"kWidgetIsEnabled=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,1,"kButtonUp=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,1,"kButtonDown=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,1,"kButtonEngaged=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EButtonState),-1,-1,1,"kButtonDisabled=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxIcon),-1,-1,1,"kMBIconStop=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxIcon),-1,-1,1,"kMBIconQuestion=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxIcon),-1,-1,1,"kMBIconExclamation=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxIcon),-1,-1,1,"kMBIconAsterisk=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBYes=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBNo=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBOk=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBApply=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBRetry=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBIgnore=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBCancel=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBClose=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBDismiss=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBYesAll=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBNoAll=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBAppend=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMsgBoxButton),-1,-1,1,"kMBNewer=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuActiveMask=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuEnableMask=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuDefaultMask=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuCheckedMask=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuRadioMask=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuHideMask=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryState),-1,-1,1,"kMenuRadioEntryMask=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryType),-1,-1,1,"kMenuSeparator=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryType),-1,-1,1,"kMenuLabel=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryType),-1,-1,1,"kMenuEntry=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_EMenuEntryType),-1,-1,1,"kMenuPopup=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETableLayoutHints),-1,-1,1,"kLHintsShrinkX=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETableLayoutHints),-1,-1,1,"kLHintsShrinkY=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETableLayoutHints),-1,-1,1,"kLHintsFillX=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui1LN_ETableLayoutHints),-1,-1,1,"kLHintsFillY=2048",0,(char*)NULL);
}

static void G__cpp_setup_global6() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Gui1() {
  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();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
   G__memfunc_setup("MK_MSG", 478, G__G__Gui1__0_340, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i 'EWidgetMessageTypes' - 0 - msg i 'EWidgetMessageTypes' - 0 - submsg", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("GET_MSG", 550, G__G__Gui1__0_341, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("GET_SUBMSG", 784, G__G__Gui1__0_342, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Gui1() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Gui1LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_EGEventType = { "EGEventType" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EGraphicsFunction = { "EGraphicsFunction" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_SetWindowAttributes_t = { "SetWindowAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Gui1LN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__Gui1LN_GCValues_t = { "GCValues_t" , 115 , -1 };
G__linked_taginfo G__G__Gui1LN_PictureAttributes_t = { "PictureAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Gui1LN_EInitialState = { "EInitialState" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGClient = { "TGClient" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TRefCnt = { "TRefCnt" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGResourcePool = { "TGResourcePool" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGPicturePool = { "TGPicturePool" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGPicture = { "TGPicture" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGGCPool = { "TGGCPool" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGGC = { "TGGC" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGFontPool = { "TGFontPool" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGFont = { "TGFont" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMimeTypes = { "TGMimeTypes" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGUnknownWindowHandler = { "TGUnknownWindowHandler" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGIdleHandler = { "TGIdleHandler" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGWindowcLcLEEditMode = { "TGWindow::EEditMode" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_THashTable = { "THashTable" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGSelectedPicture = { "TGSelectedPicture" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGDimension = { "TGDimension" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGPosition = { "TGPosition" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGLongPosition = { "TGLongPosition" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGInsets = { "TGInsets" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGRectangle = { "TGRectangle" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTextLayout = { "TGTextLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_ELayoutHints = { "ELayoutHints" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGFrameElement = { "TGFrameElement" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGLayoutManager = { "TGLayoutManager" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGVerticalLayout = { "TGVerticalLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHorizontalLayout = { "TGHorizontalLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGRowLayout = { "TGRowLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGColumnLayout = { "TGColumnLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMatrixLayout = { "TGMatrixLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTileLayout = { "TGTileLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGListLayout = { "TGListLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGListDetailsLayout = { "TGListDetailsLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGString = { "TGString" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHotString = { "TGHotString" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGVFileSplitter = { "TGVFileSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TDNDData = { "TDNDData" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_EFrameState = { "EFrameState" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EFrameCleanup = { "EFrameCleanup" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EFrameType = { "EFrameType" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EMWMHints = { "EMWMHints" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGFramecLcLdA = { "TGFrame::$" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMainFramecLcLdA = { "TGMainFrame::$" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTransientFramecLcLEPlacement = { "TGTransientFrame::EPlacement" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGGroupFrame = { "TGGroupFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGGroupFramecLcLETitlePos = { "TGGroupFrame::ETitlePos" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHeaderFrame = { "TGHeaderFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_EWidgetMessageTypes = { "EWidgetMessageTypes" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_ETextJustification = { "ETextJustification" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EWidgetStatus = { "EWidgetStatus" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGWidget = { "TGWidget" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TImage = { "TImage" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGIcon = { "TGIcon" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TColor = { "TColor" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_EButtonState = { "EButtonState" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGToolTip = { "TGToolTip" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGButtonGroup = { "TGButtonGroup" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGSplitButton = { "TGSplitButton" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTextBuffer = { "TGTextBuffer" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TBlinkTimer = { "TBlinkTimer" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTextEntrycLcLEEchoMode = { "TGTextEntry::EEchoMode" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTextEntrycLcLEInsertMode = { "TGTextEntry::EInsertMode" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EMsgBoxIcon = { "EMsgBoxIcon" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EMsgBoxButton = { "EMsgBoxButton" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMsgBox = { "TGMsgBox" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_EMenuEntryState = { "EMenuEntryState" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_EMenuEntryType = { "EMenuEntryType" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMenuTitle = { "TGMenuTitle" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGMenuEntry = { "TGMenuEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGCanvas = { "TGCanvas" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGShutterItem = { "TGShutterItem" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGShutter = { "TGShutter" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHorizontal3DLine = { "TGHorizontal3DLine" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGVertical3DLine = { "TGVertical3DLine" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGProgressBar = { "TGProgressBar" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGProgressBarcLcLEBarType = { "TGProgressBar::EBarType" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGProgressBarcLcLEFillType = { "TGProgressBar::EFillType" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGProgressBarcLcLdA = { "TGProgressBar::$" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHProgressBar = { "TGHProgressBar" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGVProgressBar = { "TGVProgressBar" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGVButtonGroup = { "TGVButtonGroup" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGHButtonGroup = { "TGHButtonGroup" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberFormat = { "TGNumberFormat" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberFormatcLcLEStyle = { "TGNumberFormat::EStyle" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberFormatcLcLEAttribute = { "TGNumberFormat::EAttribute" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberFormatcLcLELimit = { "TGNumberFormat::ELimit" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberFormatcLcLEStepSize = { "TGNumberFormat::EStepSize" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberEntryField = { "TGNumberEntryField" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGNumberEntryLayout = { "TGNumberEntryLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_ETableLayoutHints = { "ETableLayoutHints" , 101 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTableLayoutHints = { "TGTableLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTableLayout = { "TGTableLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGTableLayoutcLcLTableData_t = { "TGTableLayout::TableData_t" , 115 , -1 };
G__linked_taginfo G__G__Gui1LN_TGInputDialog = { "TGInputDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGFrameElementPack = { "TGFrameElementPack" , 99 , -1 };
G__linked_taginfo G__G__Gui1LN_TGPack = { "TGPack" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Gui1() {
  G__G__Gui1LN_TClass.tagnum = -1 ;
  G__G__Gui1LN_TBuffer.tagnum = -1 ;
  G__G__Gui1LN_TMemberInspector.tagnum = -1 ;
  G__G__Gui1LN_TObject.tagnum = -1 ;
  G__G__Gui1LN_TString.tagnum = -1 ;
  G__G__Gui1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Gui1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Gui1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui1LN_TList.tagnum = -1 ;
  G__G__Gui1LN_TTimer.tagnum = -1 ;
  G__G__Gui1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Gui1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui1LN_EGEventType.tagnum = -1 ;
  G__G__Gui1LN_EGraphicsFunction.tagnum = -1 ;
  G__G__Gui1LN_SetWindowAttributes_t.tagnum = -1 ;
  G__G__Gui1LN_Event_t.tagnum = -1 ;
  G__G__Gui1LN_GCValues_t.tagnum = -1 ;
  G__G__Gui1LN_PictureAttributes_t.tagnum = -1 ;
  G__G__Gui1LN_EInitialState.tagnum = -1 ;
  G__G__Gui1LN_TGClient.tagnum = -1 ;
  G__G__Gui1LN_TGObject.tagnum = -1 ;
  G__G__Gui1LN_TRefCnt.tagnum = -1 ;
  G__G__Gui1LN_TQObject.tagnum = -1 ;
  G__G__Gui1LN_THashList.tagnum = -1 ;
  G__G__Gui1LN_TGWindow.tagnum = -1 ;
  G__G__Gui1LN_TGResourcePool.tagnum = -1 ;
  G__G__Gui1LN_TGPicturePool.tagnum = -1 ;
  G__G__Gui1LN_TGPicture.tagnum = -1 ;
  G__G__Gui1LN_TGGCPool.tagnum = -1 ;
  G__G__Gui1LN_TGGC.tagnum = -1 ;
  G__G__Gui1LN_TGFontPool.tagnum = -1 ;
  G__G__Gui1LN_TGFont.tagnum = -1 ;
  G__G__Gui1LN_TGMimeTypes.tagnum = -1 ;
  G__G__Gui1LN_TGUnknownWindowHandler.tagnum = -1 ;
  G__G__Gui1LN_TGIdleHandler.tagnum = -1 ;
  G__G__Gui1LN_TGWindowcLcLEEditMode.tagnum = -1 ;
  G__G__Gui1LN_THashTable.tagnum = -1 ;
  G__G__Gui1LN_TGSelectedPicture.tagnum = -1 ;
  G__G__Gui1LN_TGDimension.tagnum = -1 ;
  G__G__Gui1LN_TGPosition.tagnum = -1 ;
  G__G__Gui1LN_TGLongPosition.tagnum = -1 ;
  G__G__Gui1LN_TGInsets.tagnum = -1 ;
  G__G__Gui1LN_TGRectangle.tagnum = -1 ;
  G__G__Gui1LN_TGTextLayout.tagnum = -1 ;
  G__G__Gui1LN_ELayoutHints.tagnum = -1 ;
  G__G__Gui1LN_TGFrame.tagnum = -1 ;
  G__G__Gui1LN_TGCompositeFrame.tagnum = -1 ;
  G__G__Gui1LN_TGLayoutHints.tagnum = -1 ;
  G__G__Gui1LN_TGFrameElement.tagnum = -1 ;
  G__G__Gui1LN_TGLayoutManager.tagnum = -1 ;
  G__G__Gui1LN_TGVerticalLayout.tagnum = -1 ;
  G__G__Gui1LN_TGHorizontalLayout.tagnum = -1 ;
  G__G__Gui1LN_TGRowLayout.tagnum = -1 ;
  G__G__Gui1LN_TGColumnLayout.tagnum = -1 ;
  G__G__Gui1LN_TGMatrixLayout.tagnum = -1 ;
  G__G__Gui1LN_TGTileLayout.tagnum = -1 ;
  G__G__Gui1LN_TGListLayout.tagnum = -1 ;
  G__G__Gui1LN_TGListDetailsLayout.tagnum = -1 ;
  G__G__Gui1LN_TGString.tagnum = -1 ;
  G__G__Gui1LN_TGHotString.tagnum = -1 ;
  G__G__Gui1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Gui1LN_TGTextButton.tagnum = -1 ;
  G__G__Gui1LN_TGVFileSplitter.tagnum = -1 ;
  G__G__Gui1LN_TDNDData.tagnum = -1 ;
  G__G__Gui1LN_EFrameState.tagnum = -1 ;
  G__G__Gui1LN_EFrameCleanup.tagnum = -1 ;
  G__G__Gui1LN_EFrameType.tagnum = -1 ;
  G__G__Gui1LN_EMWMHints.tagnum = -1 ;
  G__G__Gui1LN_TGFramecLcLdA.tagnum = -1 ;
  G__G__Gui1LN_TGVerticalFrame.tagnum = -1 ;
  G__G__Gui1LN_TGHorizontalFrame.tagnum = -1 ;
  G__G__Gui1LN_TGMainFrame.tagnum = -1 ;
  G__G__Gui1LN_TGMainFramecLcLdA.tagnum = -1 ;
  G__G__Gui1LN_TGTransientFrame.tagnum = -1 ;
  G__G__Gui1LN_TGTransientFramecLcLEPlacement.tagnum = -1 ;
  G__G__Gui1LN_TGGroupFrame.tagnum = -1 ;
  G__G__Gui1LN_TGGroupFramecLcLETitlePos.tagnum = -1 ;
  G__G__Gui1LN_TGHeaderFrame.tagnum = -1 ;
  G__G__Gui1LN_EWidgetMessageTypes.tagnum = -1 ;
  G__G__Gui1LN_ETextJustification.tagnum = -1 ;
  G__G__Gui1LN_EWidgetStatus.tagnum = -1 ;
  G__G__Gui1LN_TGWidget.tagnum = -1 ;
  G__G__Gui1LN_TImage.tagnum = -1 ;
  G__G__Gui1LN_TGIcon.tagnum = -1 ;
  G__G__Gui1LN_TColor.tagnum = -1 ;
  G__G__Gui1LN_TGLabel.tagnum = -1 ;
  G__G__Gui1LN_EButtonState.tagnum = -1 ;
  G__G__Gui1LN_TGToolTip.tagnum = -1 ;
  G__G__Gui1LN_TGButtonGroup.tagnum = -1 ;
  G__G__Gui1LN_TGPopupMenu.tagnum = -1 ;
  G__G__Gui1LN_TGButton.tagnum = -1 ;
  G__G__Gui1LN_TGPictureButton.tagnum = -1 ;
  G__G__Gui1LN_TGCheckButton.tagnum = -1 ;
  G__G__Gui1LN_TGRadioButton.tagnum = -1 ;
  G__G__Gui1LN_TGSplitButton.tagnum = -1 ;
  G__G__Gui1LN_TGTextBuffer.tagnum = -1 ;
  G__G__Gui1LN_TBlinkTimer.tagnum = -1 ;
  G__G__Gui1LN_TGTextEntry.tagnum = -1 ;
  G__G__Gui1LN_TGTextEntrycLcLEEchoMode.tagnum = -1 ;
  G__G__Gui1LN_TGTextEntrycLcLEInsertMode.tagnum = -1 ;
  G__G__Gui1LN_EMsgBoxIcon.tagnum = -1 ;
  G__G__Gui1LN_EMsgBoxButton.tagnum = -1 ;
  G__G__Gui1LN_TGMsgBox.tagnum = -1 ;
  G__G__Gui1LN_EMenuEntryState.tagnum = -1 ;
  G__G__Gui1LN_EMenuEntryType.tagnum = -1 ;
  G__G__Gui1LN_TGMenuBar.tagnum = -1 ;
  G__G__Gui1LN_TGMenuTitle.tagnum = -1 ;
  G__G__Gui1LN_TGMenuEntry.tagnum = -1 ;
  G__G__Gui1LN_TGCanvas.tagnum = -1 ;
  G__G__Gui1LN_TGShutterItem.tagnum = -1 ;
  G__G__Gui1LN_TGShutter.tagnum = -1 ;
  G__G__Gui1LN_TGHorizontal3DLine.tagnum = -1 ;
  G__G__Gui1LN_TGVertical3DLine.tagnum = -1 ;
  G__G__Gui1LN_TGProgressBar.tagnum = -1 ;
  G__G__Gui1LN_TGProgressBarcLcLEBarType.tagnum = -1 ;
  G__G__Gui1LN_TGProgressBarcLcLEFillType.tagnum = -1 ;
  G__G__Gui1LN_TGProgressBarcLcLdA.tagnum = -1 ;
  G__G__Gui1LN_TGHProgressBar.tagnum = -1 ;
  G__G__Gui1LN_TGVProgressBar.tagnum = -1 ;
  G__G__Gui1LN_TMap.tagnum = -1 ;
  G__G__Gui1LN_TGVButtonGroup.tagnum = -1 ;
  G__G__Gui1LN_TGHButtonGroup.tagnum = -1 ;
  G__G__Gui1LN_TGNumberFormat.tagnum = -1 ;
  G__G__Gui1LN_TGNumberFormatcLcLEStyle.tagnum = -1 ;
  G__G__Gui1LN_TGNumberFormatcLcLEAttribute.tagnum = -1 ;
  G__G__Gui1LN_TGNumberFormatcLcLELimit.tagnum = -1 ;
  G__G__Gui1LN_TGNumberFormatcLcLEStepSize.tagnum = -1 ;
  G__G__Gui1LN_TGNumberEntryField.tagnum = -1 ;
  G__G__Gui1LN_TGNumberEntry.tagnum = -1 ;
  G__G__Gui1LN_TGNumberEntryLayout.tagnum = -1 ;
  G__G__Gui1LN_ETableLayoutHints.tagnum = -1 ;
  G__G__Gui1LN_TGTableLayoutHints.tagnum = -1 ;
  G__G__Gui1LN_TGTableLayout.tagnum = -1 ;
  G__G__Gui1LN_TGTableLayoutcLcLTableData_t.tagnum = -1 ;
  G__G__Gui1LN_TGInputDialog.tagnum = -1 ;
  G__G__Gui1LN_TGFrameElementPack.tagnum = -1 ;
  G__G__Gui1LN_TGPack.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Gui1() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TString);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TTimer);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_EGEventType);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_EGraphicsFunction);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_SetWindowAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_GCValues_t);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_PictureAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_EInitialState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGClient),sizeof(TGClient),-1,32512,"Class making connection to display server",G__setup_memvarTGClient,G__setup_memfuncTGClient);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGObject),sizeof(TGObject),-1,32512,"ROOT GUI base class",G__setup_memvarTGObject,G__setup_memfuncTGObject);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TRefCnt);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_THashList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGWindow),sizeof(TGWindow),-1,65280,"GUI Window base class",G__setup_memvarTGWindow,G__setup_memfuncTGWindow);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGResourcePool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGPicturePool),sizeof(TGPicturePool),-1,65024,"Picture and icon cache",G__setup_memvarTGPicturePool,G__setup_memfuncTGPicturePool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGPicture),sizeof(TGPicture),-1,62464,"Pictures and icons used by the GUI classes",G__setup_memvarTGPicture,G__setup_memfuncTGPicture);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGGCPool),sizeof(TGGCPool),-1,65024,"Graphics context pool",G__setup_memvarTGGCPool,G__setup_memfuncTGGCPool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGGC),sizeof(TGGC),-1,65280,"Graphics context",G__setup_memvarTGGC,G__setup_memfuncTGGC);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGFontPool);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGFont);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMimeTypes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGUnknownWindowHandler),sizeof(TGUnknownWindowHandler),-1,29953,"Abstract event handler for unknown windows",G__setup_memvarTGUnknownWindowHandler,G__setup_memfuncTGUnknownWindowHandler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGIdleHandler),sizeof(TGIdleHandler),-1,62464,"Idle event handler",G__setup_memvarTGIdleHandler,G__setup_memfuncTGIdleHandler);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGWindowcLcLEEditMode);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_THashTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGSelectedPicture),sizeof(TGSelectedPicture),-1,65024,"Selected looking picture",G__setup_memvarTGSelectedPicture,G__setup_memfuncTGSelectedPicture);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGDimension),sizeof(TGDimension),-1,34560,"Dimension object (width, height)",G__setup_memvarTGDimension,G__setup_memfuncTGDimension);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGPosition),sizeof(TGPosition),-1,34560,"Position object (x and y are Int_t)",G__setup_memvarTGPosition,G__setup_memfuncTGPosition);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGLongPosition),sizeof(TGLongPosition),-1,34560,"Position object (x and y are Long_t)",G__setup_memvarTGLongPosition,G__setup_memfuncTGLongPosition);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGInsets),sizeof(TGInsets),-1,34560,"Inset (left, right, top, bottom)",G__setup_memvarTGInsets,G__setup_memfuncTGInsets);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGRectangle),sizeof(TGRectangle),-1,34560,"Rectangle object",G__setup_memvarTGRectangle,G__setup_memfuncTGRectangle);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTextLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_ELayoutHints),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGFrame),sizeof(TGFrame),-1,65280,"Base class for simple widgets (button, etc.)",G__setup_memvarTGFrame,G__setup_memfuncTGFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGCompositeFrame),sizeof(TGCompositeFrame),-1,65280,"Base class for composite widgets (menubars, etc.)",G__setup_memvarTGCompositeFrame,G__setup_memfuncTGCompositeFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGLayoutHints),sizeof(TGLayoutHints),-1,65280,"Class describing GUI layout hints",G__setup_memvarTGLayoutHints,G__setup_memfuncTGLayoutHints);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGFrameElement),sizeof(TGFrameElement),-1,65280,"Base class used in GUI containers",G__setup_memvarTGFrameElement,G__setup_memfuncTGFrameElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGLayoutManager),sizeof(TGLayoutManager),-1,28930,"Layout manager abstract base class",G__setup_memvarTGLayoutManager,G__setup_memfuncTGLayoutManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGVerticalLayout),sizeof(TGVerticalLayout),-1,64000,"Vertical layout manager",G__setup_memvarTGVerticalLayout,G__setup_memfuncTGVerticalLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHorizontalLayout),sizeof(TGHorizontalLayout),-1,61440,"Horizontal layout manager",G__setup_memvarTGHorizontalLayout,G__setup_memfuncTGHorizontalLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGRowLayout),sizeof(TGRowLayout),-1,61440,"Row layout manager",G__setup_memvarTGRowLayout,G__setup_memfuncTGRowLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGColumnLayout),sizeof(TGColumnLayout),-1,61440,"Column layout manager",G__setup_memvarTGColumnLayout,G__setup_memfuncTGColumnLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMatrixLayout),sizeof(TGMatrixLayout),-1,64000,"Matrix layout manager",G__setup_memvarTGMatrixLayout,G__setup_memfuncTGMatrixLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTileLayout),sizeof(TGTileLayout),-1,64000,"Tile layout manager",G__setup_memvarTGTileLayout,G__setup_memfuncTGTileLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGListLayout),sizeof(TGListLayout),-1,61440,"Layout manager for TGListView widget",G__setup_memvarTGListLayout,G__setup_memfuncTGListLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGListDetailsLayout),sizeof(TGListDetailsLayout),-1,61440,"Layout manager for TGListView details",G__setup_memvarTGListDetailsLayout,G__setup_memfuncTGListDetailsLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGString),sizeof(TGString),-1,34048,"Graphics string",G__setup_memvarTGString,G__setup_memfuncTGString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHotString),sizeof(TGHotString),-1,32768,"Graphics string with hot character",G__setup_memvarTGHotString,G__setup_memfuncTGHotString);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTextButton),sizeof(TGTextButton),-1,65280,"A text button widget",G__setup_memvarTGTextButton,G__setup_memfuncTGTextButton);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGVFileSplitter);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TDNDData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EFrameState),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EFrameCleanup),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EFrameType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EMWMHints),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGFramecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGVerticalFrame),sizeof(TGVerticalFrame),-1,61696,"Composite frame with vertical child layout",G__setup_memvarTGVerticalFrame,G__setup_memfuncTGVerticalFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHorizontalFrame),sizeof(TGHorizontalFrame),-1,61696,"Composite frame with horizontal child layout",G__setup_memvarTGHorizontalFrame,G__setup_memfuncTGHorizontalFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMainFrame),sizeof(TGMainFrame),-1,65280,"Top level window frame",G__setup_memvarTGMainFrame,G__setup_memfuncTGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMainFramecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTransientFrame),sizeof(TGTransientFrame),-1,64256,"Frame for dialog (transient) windows",G__setup_memvarTGTransientFrame,G__setup_memfuncTGTransientFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTransientFramecLcLEPlacement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGGroupFrame),sizeof(TGGroupFrame),-1,65280,"A composite frame with border and title",G__setup_memvarTGGroupFrame,G__setup_memfuncTGGroupFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGGroupFramecLcLETitlePos),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHeaderFrame),sizeof(TGHeaderFrame),-1,64256,"Header frame with buttons and splitters",G__setup_memvarTGHeaderFrame,G__setup_memfuncTGHeaderFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EWidgetMessageTypes),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_ETextJustification),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EWidgetStatus),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGWidget),sizeof(TGWidget),-1,36608,"Widget base class",G__setup_memvarTGWidget,G__setup_memfuncTGWidget);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TImage);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGIcon),sizeof(TGIcon),-1,65280,"Icon GUI class",G__setup_memvarTGIcon,G__setup_memfuncTGIcon);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TColor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGLabel),sizeof(TGLabel),-1,65280,"A label GUI element",G__setup_memvarTGLabel,G__setup_memfuncTGLabel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EButtonState),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGToolTip);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGButtonGroup),sizeof(TGButtonGroup),-1,65280,"Organizes TGButtons in a group",G__setup_memvarTGButtonGroup,G__setup_memfuncTGButtonGroup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGPopupMenu),sizeof(TGPopupMenu),-1,65280,"Popup menu",G__setup_memvarTGPopupMenu,G__setup_memfuncTGPopupMenu);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGButton),sizeof(TGButton),-1,65280,"Button widget abstract base class",G__setup_memvarTGButton,G__setup_memfuncTGButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGPictureButton),sizeof(TGPictureButton),-1,65280,"A picture button widget",G__setup_memvarTGPictureButton,G__setup_memfuncTGPictureButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGCheckButton),sizeof(TGCheckButton),-1,65280,"A check button widget",G__setup_memvarTGCheckButton,G__setup_memfuncTGCheckButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGRadioButton),sizeof(TGRadioButton),-1,65280,"A radio button widget",G__setup_memvarTGRadioButton,G__setup_memfuncTGRadioButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGSplitButton),sizeof(TGSplitButton),-1,65024,"a split button widget",G__setup_memvarTGSplitButton,G__setup_memfuncTGSplitButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTextBuffer),sizeof(TGTextBuffer),-1,36608,"Text buffer used by widgets like TGTextEntry, etc.",G__setup_memvarTGTextBuffer,G__setup_memfuncTGTextBuffer);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TBlinkTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTextEntry),sizeof(TGTextEntry),-1,65280,"The TGTextEntry widget is a simple line editor for inputting text",G__setup_memvarTGTextEntry,G__setup_memfuncTGTextEntry);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTextEntrycLcLEEchoMode);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTextEntrycLcLEInsertMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EMsgBoxIcon),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EMsgBoxButton),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMsgBox),sizeof(TGMsgBox),-1,65280,"A message dialog box",G__setup_memvarTGMsgBox,G__setup_memfuncTGMsgBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EMenuEntryState),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_EMenuEntryType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMenuBar),sizeof(TGMenuBar),-1,65280,"Menu bar class",G__setup_memvarTGMenuBar,G__setup_memfuncTGMenuBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMenuTitle),sizeof(TGMenuTitle),-1,65280,"Menu title class",G__setup_memvarTGMenuTitle,G__setup_memfuncTGMenuTitle);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGMenuEntry),sizeof(TGMenuEntry),-1,32512,"Menu entry class",G__setup_memvarTGMenuEntry,G__setup_memfuncTGMenuEntry);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGCanvas);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGShutterItem),sizeof(TGShutterItem),-1,65280,"Shutter widget item",G__setup_memvarTGShutterItem,G__setup_memfuncTGShutterItem);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGShutter),sizeof(TGShutter),-1,65280,"Shutter widget",G__setup_memvarTGShutter,G__setup_memfuncTGShutter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHorizontal3DLine),sizeof(TGHorizontal3DLine),-1,61696,"A horizontal 3D separator line",G__setup_memvarTGHorizontal3DLine,G__setup_memfuncTGHorizontal3DLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGVertical3DLine),sizeof(TGVertical3DLine),-1,61696,"A vertical 3D separator line",G__setup_memvarTGVertical3DLine,G__setup_memfuncTGVertical3DLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGProgressBar),sizeof(TGProgressBar),-1,62465,"Progress bar abstract base class",G__setup_memvarTGProgressBar,G__setup_memfuncTGProgressBar);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGProgressBarcLcLEBarType);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGProgressBarcLcLEFillType);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGProgressBarcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHProgressBar),sizeof(TGHProgressBar),-1,62720,"Horizontal progress bar widget",G__setup_memvarTGHProgressBar,G__setup_memfuncTGHProgressBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGVProgressBar),sizeof(TGVProgressBar),-1,62720,"Vertical progress bar widget",G__setup_memvarTGVProgressBar,G__setup_memfuncTGVProgressBar);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGVButtonGroup),sizeof(TGVButtonGroup),-1,62464,"A button group with one vertical column",G__setup_memvarTGVButtonGroup,G__setup_memfuncTGVButtonGroup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGHButtonGroup),sizeof(TGHButtonGroup),-1,62464,"A button group with one horizontal row",G__setup_memvarTGHButtonGroup,G__setup_memfuncTGHButtonGroup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberFormat),sizeof(TGNumberFormat),-1,1024,"Class defining namespace for several enums used by TGNumberEntry",G__setup_memvarTGNumberFormat,G__setup_memfuncTGNumberFormat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberFormatcLcLEStyle),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberFormatcLcLEAttribute),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberFormatcLcLELimit),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberFormatcLcLEStepSize),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberEntryField),sizeof(TGNumberEntryField),-1,61696,"A text entry field used by a TGNumberEntry",G__setup_memvarTGNumberEntryField,G__setup_memfuncTGNumberEntryField);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberEntry),sizeof(TGNumberEntry),-1,65280,"Entry field widget for several numeric formats",G__setup_memvarTGNumberEntry,G__setup_memfuncTGNumberEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGNumberEntryLayout),sizeof(TGNumberEntryLayout),-1,64000,"Layout manager for number entry widget",G__setup_memvarTGNumberEntryLayout,G__setup_memfuncTGNumberEntryLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_ETableLayoutHints),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTableLayoutHints),sizeof(TGTableLayoutHints),-1,65024,"Class describing GUI table layout hints",G__setup_memvarTGTableLayoutHints,G__setup_memfuncTGTableLayoutHints);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTableLayout),sizeof(TGTableLayout),-1,65024,"Table layout manager",G__setup_memvarTGTableLayout,G__setup_memfuncTGTableLayout);
   G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGTableLayoutcLcLTableData_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGInputDialog),sizeof(TGInputDialog),-1,65280,"Simple input dialog",G__setup_memvarTGInputDialog,G__setup_memfuncTGInputDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGFrameElementPack),sizeof(TGFrameElementPack),-1,64000,"Class used in TGPack.",G__setup_memvarTGFrameElementPack,G__setup_memfuncTGFrameElementPack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui1LN_TGPack),sizeof(TGPack),-1,65280,"Horizontal or vertical stack of frames.",G__setup_memvarTGPack,G__setup_memfuncTGPack);
}
extern "C" void G__cpp_setupG__Gui1(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Gui1()");
  G__set_cpp_environmentG__Gui1();
  G__cpp_setup_tagtableG__Gui1();

  G__cpp_setup_inheritanceG__Gui1();

  G__cpp_setup_typetableG__Gui1();

  G__cpp_setup_memvarG__Gui1();

  G__cpp_setup_memfuncG__Gui1();
  G__cpp_setup_globalG__Gui1();
  G__cpp_setup_funcG__Gui1();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Gui1();
  return;
}
class G__cpp_setup_initG__Gui1 {
  public:
    G__cpp_setup_initG__Gui1() { G__add_setup_func("G__Gui1",(G__incsetup)(&G__cpp_setupG__Gui1)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Gui1() { G__remove_setup_func("G__Gui1"); }
};
G__cpp_setup_initG__Gui1 G__cpp_setup_initializerG__Gui1;

---