G__Gui2.cxx

Go to the documentation of this file.

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

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

#define R__DICTIONARY_FILENAME guidIguidIsrcdIG__Gui2
#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__Gui2.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 TGResourcePool_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGResourcePool(void *p);
   static void deleteArray_TGResourcePool(void *p);
   static void destruct_TGResourcePool(void *p);
   static void streamer_TGResourcePool(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGFontPool_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGFontPool(void *p);
   static void deleteArray_TGFontPool(void *p);
   static void destruct_TGFontPool(void *p);
   static void streamer_TGFontPool(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGFont_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGFont(void *p);
   static void deleteArray_TGFont(void *p);
   static void destruct_TGFont(void *p);
   static void streamer_TGFont(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGMimeTypes_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGMimeTypes(void *p);
   static void deleteArray_TGMimeTypes(void *p);
   static void destruct_TGMimeTypes(void *p);
   static void streamer_TGMimeTypes(TBuffer &buf, void *obj);

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

namespace ROOT {
   void FontMetrics_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void FontMetrics_t_Dictionary();
   static void *new_FontMetrics_t(void *p = 0);
   static void *newArray_FontMetrics_t(Long_t size, void *p);
   static void delete_FontMetrics_t(void *p);
   static void deleteArray_FontMetrics_t(void *p);
   static void destruct_FontMetrics_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::FontMetrics_t*)
   {
      ::FontMetrics_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::FontMetrics_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("FontMetrics_t", "include/TGFont.h", 67,
                  typeid(::FontMetrics_t), DefineBehavior(ptr, ptr),
                  0, &FontMetrics_t_Dictionary, isa_proxy, 0,
                  sizeof(::FontMetrics_t) );
      instance.SetNew(&new_FontMetrics_t);
      instance.SetNewArray(&newArray_FontMetrics_t);
      instance.SetDelete(&delete_FontMetrics_t);
      instance.SetDeleteArray(&deleteArray_FontMetrics_t);
      instance.SetDestructor(&destruct_FontMetrics_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::FontMetrics_t*)
   {
      return GenerateInitInstanceLocal((::FontMetrics_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::FontMetrics_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void FontAttributes_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void FontAttributes_t_Dictionary();
   static void *new_FontAttributes_t(void *p = 0);
   static void *newArray_FontAttributes_t(Long_t size, void *p);
   static void delete_FontAttributes_t(void *p);
   static void deleteArray_FontAttributes_t(void *p);
   static void destruct_FontAttributes_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::FontAttributes_t*)
   {
      ::FontAttributes_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::FontAttributes_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("FontAttributes_t", "include/TGFont.h", 76,
                  typeid(::FontAttributes_t), DefineBehavior(ptr, ptr),
                  0, &FontAttributes_t_Dictionary, isa_proxy, 0,
                  sizeof(::FontAttributes_t) );
      instance.SetNew(&new_FontAttributes_t);
      instance.SetNewArray(&newArray_FontAttributes_t);
      instance.SetDelete(&delete_FontAttributes_t);
      instance.SetDeleteArray(&deleteArray_FontAttributes_t);
      instance.SetDestructor(&destruct_FontAttributes_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::FontAttributes_t*)
   {
      return GenerateInitInstanceLocal((::FontAttributes_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::FontAttributes_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGTextLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextLayout(void *p = 0);
   static void *newArray_TGTextLayout(Long_t size, void *p);
   static void delete_TGTextLayout(void *p);
   static void deleteArray_TGTextLayout(void *p);
   static void destruct_TGTextLayout(void *p);
   static void streamer_TGTextLayout(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTextLayout*)
   {
      ::TGTextLayout *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTextLayout >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTextLayout", ::TGTextLayout::Class_Version(), "include/TGFont.h", 119,
                  typeid(::TGTextLayout), DefineBehavior(ptr, ptr),
                  &::TGTextLayout::Dictionary, isa_proxy, 0,
                  sizeof(::TGTextLayout) );
      instance.SetNew(&new_TGTextLayout);
      instance.SetNewArray(&newArray_TGTextLayout);
      instance.SetDelete(&delete_TGTextLayout);
      instance.SetDeleteArray(&deleteArray_TGTextLayout);
      instance.SetDestructor(&destruct_TGTextLayout);
      instance.SetStreamerFunc(&streamer_TGTextLayout);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTextLayout*)
   {
      return GenerateInitInstanceLocal((::TGTextLayout*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTextLayout*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGVFileSplitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVFileSplitter(void *p = 0);
   static void *newArray_TGVFileSplitter(Long_t size, void *p);
   static void delete_TGVFileSplitter(void *p);
   static void deleteArray_TGVFileSplitter(void *p);
   static void destruct_TGVFileSplitter(void *p);
   static void streamer_TGVFileSplitter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVFileSplitter*)
   {
      ::TGVFileSplitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVFileSplitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVFileSplitter", ::TGVFileSplitter::Class_Version(), "include/TGSplitter.h", 138,
                  typeid(::TGVFileSplitter), DefineBehavior(ptr, ptr),
                  &::TGVFileSplitter::Dictionary, isa_proxy, 0,
                  sizeof(::TGVFileSplitter) );
      instance.SetNew(&new_TGVFileSplitter);
      instance.SetNewArray(&newArray_TGVFileSplitter);
      instance.SetDelete(&delete_TGVFileSplitter);
      instance.SetDeleteArray(&deleteArray_TGVFileSplitter);
      instance.SetDestructor(&destruct_TGVFileSplitter);
      instance.SetStreamerFunc(&streamer_TGVFileSplitter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVFileSplitter*)
   {
      return GenerateInitInstanceLocal((::TGVFileSplitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVFileSplitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGToolTip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGToolTip(void *p = 0);
   static void *newArray_TGToolTip(Long_t size, void *p);
   static void delete_TGToolTip(void *p);
   static void deleteArray_TGToolTip(void *p);
   static void destruct_TGToolTip(void *p);
   static void streamer_TGToolTip(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGScrollBarElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGScrollBarElement(void *p = 0);
   static void *newArray_TGScrollBarElement(Long_t size, void *p);
   static void delete_TGScrollBarElement(void *p);
   static void deleteArray_TGScrollBarElement(void *p);
   static void destruct_TGScrollBarElement(void *p);
   static void streamer_TGScrollBarElement(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGScrollBarElement*)
   {
      ::TGScrollBarElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGScrollBarElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGScrollBarElement", ::TGScrollBarElement::Class_Version(), "include/TGScrollBar.h", 50,
                  typeid(::TGScrollBarElement), DefineBehavior(ptr, ptr),
                  &::TGScrollBarElement::Dictionary, isa_proxy, 0,
                  sizeof(::TGScrollBarElement) );
      instance.SetNew(&new_TGScrollBarElement);
      instance.SetNewArray(&newArray_TGScrollBarElement);
      instance.SetDelete(&delete_TGScrollBarElement);
      instance.SetDeleteArray(&deleteArray_TGScrollBarElement);
      instance.SetDestructor(&destruct_TGScrollBarElement);
      instance.SetStreamerFunc(&streamer_TGScrollBarElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGScrollBarElement*)
   {
      return GenerateInitInstanceLocal((::TGScrollBarElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGScrollBarElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGScrollBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGScrollBar(void *p);
   static void deleteArray_TGScrollBar(void *p);
   static void destruct_TGScrollBar(void *p);
   static void streamer_TGScrollBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGHScrollBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHScrollBar(void *p = 0);
   static void *newArray_TGHScrollBar(Long_t size, void *p);
   static void delete_TGHScrollBar(void *p);
   static void deleteArray_TGHScrollBar(void *p);
   static void destruct_TGHScrollBar(void *p);
   static void streamer_TGHScrollBar(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGHScrollBar*)
   {
      ::TGHScrollBar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGHScrollBar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGHScrollBar", ::TGHScrollBar::Class_Version(), "include/TGScrollBar.h", 154,
                  typeid(::TGHScrollBar), DefineBehavior(ptr, ptr),
                  &::TGHScrollBar::Dictionary, isa_proxy, 0,
                  sizeof(::TGHScrollBar) );
      instance.SetNew(&new_TGHScrollBar);
      instance.SetNewArray(&newArray_TGHScrollBar);
      instance.SetDelete(&delete_TGHScrollBar);
      instance.SetDeleteArray(&deleteArray_TGHScrollBar);
      instance.SetDestructor(&destruct_TGHScrollBar);
      instance.SetStreamerFunc(&streamer_TGHScrollBar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGHScrollBar*)
   {
      return GenerateInitInstanceLocal((::TGHScrollBar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGHScrollBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGVScrollBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVScrollBar(void *p = 0);
   static void *newArray_TGVScrollBar(Long_t size, void *p);
   static void delete_TGVScrollBar(void *p);
   static void deleteArray_TGVScrollBar(void *p);
   static void destruct_TGVScrollBar(void *p);
   static void streamer_TGVScrollBar(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVScrollBar*)
   {
      ::TGVScrollBar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVScrollBar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVScrollBar", ::TGVScrollBar::Class_Version(), "include/TGScrollBar.h", 177,
                  typeid(::TGVScrollBar), DefineBehavior(ptr, ptr),
                  &::TGVScrollBar::Dictionary, isa_proxy, 0,
                  sizeof(::TGVScrollBar) );
      instance.SetNew(&new_TGVScrollBar);
      instance.SetNewArray(&newArray_TGVScrollBar);
      instance.SetDelete(&delete_TGVScrollBar);
      instance.SetDeleteArray(&deleteArray_TGVScrollBar);
      instance.SetDestructor(&destruct_TGVScrollBar);
      instance.SetStreamerFunc(&streamer_TGVScrollBar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVScrollBar*)
   {
      return GenerateInitInstanceLocal((::TGVScrollBar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVScrollBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGViewPort_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGViewPort(void *p = 0);
   static void *newArray_TGViewPort(Long_t size, void *p);
   static void delete_TGViewPort(void *p);
   static void deleteArray_TGViewPort(void *p);
   static void destruct_TGViewPort(void *p);
   static void streamer_TGViewPort(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGViewPort*)
   {
      ::TGViewPort *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGViewPort >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGViewPort", ::TGViewPort::Class_Version(), "include/TGCanvas.h", 170,
                  typeid(::TGViewPort), DefineBehavior(ptr, ptr),
                  &::TGViewPort::Dictionary, isa_proxy, 0,
                  sizeof(::TGViewPort) );
      instance.SetNew(&new_TGViewPort);
      instance.SetNewArray(&newArray_TGViewPort);
      instance.SetDelete(&delete_TGViewPort);
      instance.SetDeleteArray(&deleteArray_TGViewPort);
      instance.SetDestructor(&destruct_TGViewPort);
      instance.SetStreamerFunc(&streamer_TGViewPort);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGViewPort*)
   {
      return GenerateInitInstanceLocal((::TGViewPort*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGViewPort*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGCanvas_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGCanvas(void *p = 0);
   static void *newArray_TGCanvas(Long_t size, void *p);
   static void delete_TGCanvas(void *p);
   static void deleteArray_TGCanvas(void *p);
   static void destruct_TGCanvas(void *p);
   static void streamer_TGCanvas(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGCanvas*)
   {
      ::TGCanvas *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGCanvas >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGCanvas", ::TGCanvas::Class_Version(), "include/TGCanvas.h", 204,
                  typeid(::TGCanvas), DefineBehavior(ptr, ptr),
                  &::TGCanvas::Dictionary, isa_proxy, 0,
                  sizeof(::TGCanvas) );
      instance.SetNew(&new_TGCanvas);
      instance.SetNewArray(&newArray_TGCanvas);
      instance.SetDelete(&delete_TGCanvas);
      instance.SetDeleteArray(&deleteArray_TGCanvas);
      instance.SetDestructor(&destruct_TGCanvas);
      instance.SetStreamerFunc(&streamer_TGCanvas);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGCanvas*)
   {
      return GenerateInitInstanceLocal((::TGCanvas*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGCanvas*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGListView_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGListView(void *p);
   static void deleteArray_TGListView(void *p);
   static void destruct_TGListView(void *p);
   static void streamer_TGListView(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGContainer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGContainer(void *p = 0);
   static void *newArray_TGContainer(Long_t size, void *p);
   static void delete_TGContainer(void *p);
   static void deleteArray_TGContainer(void *p);
   static void destruct_TGContainer(void *p);
   static void streamer_TGContainer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGListBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGListBox(void *p = 0);
   static void *newArray_TGListBox(Long_t size, void *p);
   static void delete_TGListBox(void *p);
   static void deleteArray_TGListBox(void *p);
   static void destruct_TGListBox(void *p);
   static void streamer_TGListBox(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGListBox*)
   {
      ::TGListBox *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGListBox >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGListBox", ::TGListBox::Class_Version(), "include/TGListBox.h", 297,
                  typeid(::TGListBox), DefineBehavior(ptr, ptr),
                  &::TGListBox::Dictionary, isa_proxy, 0,
                  sizeof(::TGListBox) );
      instance.SetNew(&new_TGListBox);
      instance.SetNewArray(&newArray_TGListBox);
      instance.SetDelete(&delete_TGListBox);
      instance.SetDeleteArray(&deleteArray_TGListBox);
      instance.SetDestructor(&destruct_TGListBox);
      instance.SetStreamerFunc(&streamer_TGListBox);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGListBox*)
   {
      return GenerateInitInstanceLocal((::TGListBox*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGListBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLBEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLBEntry(void *p = 0);
   static void *newArray_TGLBEntry(Long_t size, void *p);
   static void delete_TGLBEntry(void *p);
   static void deleteArray_TGLBEntry(void *p);
   static void destruct_TGLBEntry(void *p);
   static void streamer_TGLBEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLBEntry*)
   {
      ::TGLBEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLBEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLBEntry", ::TGLBEntry::Class_Version(), "include/TGListBox.h", 60,
                  typeid(::TGLBEntry), DefineBehavior(ptr, ptr),
                  &::TGLBEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGLBEntry) );
      instance.SetNew(&new_TGLBEntry);
      instance.SetNewArray(&newArray_TGLBEntry);
      instance.SetDelete(&delete_TGLBEntry);
      instance.SetDeleteArray(&deleteArray_TGLBEntry);
      instance.SetDestructor(&destruct_TGLBEntry);
      instance.SetStreamerFunc(&streamer_TGLBEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLBEntry*)
   {
      return GenerateInitInstanceLocal((::TGLBEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLBEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTextLBEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextLBEntry(void *p = 0);
   static void *newArray_TGTextLBEntry(Long_t size, void *p);
   static void delete_TGTextLBEntry(void *p);
   static void deleteArray_TGTextLBEntry(void *p);
   static void destruct_TGTextLBEntry(void *p);
   static void streamer_TGTextLBEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTextLBEntry*)
   {
      ::TGTextLBEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTextLBEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTextLBEntry", ::TGTextLBEntry::Class_Version(), "include/TGListBox.h", 92,
                  typeid(::TGTextLBEntry), DefineBehavior(ptr, ptr),
                  &::TGTextLBEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGTextLBEntry) );
      instance.SetNew(&new_TGTextLBEntry);
      instance.SetNewArray(&newArray_TGTextLBEntry);
      instance.SetDelete(&delete_TGTextLBEntry);
      instance.SetDeleteArray(&deleteArray_TGTextLBEntry);
      instance.SetDestructor(&destruct_TGTextLBEntry);
      instance.SetStreamerFunc(&streamer_TGTextLBEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTextLBEntry*)
   {
      return GenerateInitInstanceLocal((::TGTextLBEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTextLBEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLineLBEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLineLBEntry(void *p = 0);
   static void *newArray_TGLineLBEntry(Long_t size, void *p);
   static void delete_TGLineLBEntry(void *p);
   static void deleteArray_TGLineLBEntry(void *p);
   static void destruct_TGLineLBEntry(void *p);
   static void streamer_TGLineLBEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLineLBEntry*)
   {
      ::TGLineLBEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLineLBEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLineLBEntry", ::TGLineLBEntry::Class_Version(), "include/TGListBox.h", 150,
                  typeid(::TGLineLBEntry), DefineBehavior(ptr, ptr),
                  &::TGLineLBEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGLineLBEntry) );
      instance.SetNew(&new_TGLineLBEntry);
      instance.SetNewArray(&newArray_TGLineLBEntry);
      instance.SetDelete(&delete_TGLineLBEntry);
      instance.SetDeleteArray(&deleteArray_TGLineLBEntry);
      instance.SetDestructor(&destruct_TGLineLBEntry);
      instance.SetStreamerFunc(&streamer_TGLineLBEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLineLBEntry*)
   {
      return GenerateInitInstanceLocal((::TGLineLBEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLineLBEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGIconLBEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGIconLBEntry(void *p = 0);
   static void *newArray_TGIconLBEntry(Long_t size, void *p);
   static void delete_TGIconLBEntry(void *p);
   static void deleteArray_TGIconLBEntry(void *p);
   static void destruct_TGIconLBEntry(void *p);
   static void streamer_TGIconLBEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGIconLBEntry*)
   {
      ::TGIconLBEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGIconLBEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGIconLBEntry", ::TGIconLBEntry::Class_Version(), "include/TGListBox.h", 192,
                  typeid(::TGIconLBEntry), DefineBehavior(ptr, ptr),
                  &::TGIconLBEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGIconLBEntry) );
      instance.SetNew(&new_TGIconLBEntry);
      instance.SetNewArray(&newArray_TGIconLBEntry);
      instance.SetDelete(&delete_TGIconLBEntry);
      instance.SetDeleteArray(&deleteArray_TGIconLBEntry);
      instance.SetDestructor(&destruct_TGIconLBEntry);
      instance.SetStreamerFunc(&streamer_TGIconLBEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGIconLBEntry*)
   {
      return GenerateInitInstanceLocal((::TGIconLBEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGIconLBEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLBContainer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLBContainer(void *p = 0);
   static void *newArray_TGLBContainer(Long_t size, void *p);
   static void delete_TGLBContainer(void *p);
   static void deleteArray_TGLBContainer(void *p);
   static void destruct_TGLBContainer(void *p);
   static void streamer_TGLBContainer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLBContainer*)
   {
      ::TGLBContainer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLBContainer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLBContainer", ::TGLBContainer::Class_Version(), "include/TGListBox.h", 231,
                  typeid(::TGLBContainer), DefineBehavior(ptr, ptr),
                  &::TGLBContainer::Dictionary, isa_proxy, 0,
                  sizeof(::TGLBContainer) );
      instance.SetNew(&new_TGLBContainer);
      instance.SetNewArray(&newArray_TGLBContainer);
      instance.SetDelete(&delete_TGLBContainer);
      instance.SetDeleteArray(&deleteArray_TGLBContainer);
      instance.SetDestructor(&destruct_TGLBContainer);
      instance.SetStreamerFunc(&streamer_TGLBContainer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLBContainer*)
   {
      return GenerateInitInstanceLocal((::TGLBContainer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLBContainer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGComboBoxPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGComboBoxPopup(void *p = 0);
   static void *newArray_TGComboBoxPopup(Long_t size, void *p);
   static void delete_TGComboBoxPopup(void *p);
   static void deleteArray_TGComboBoxPopup(void *p);
   static void destruct_TGComboBoxPopup(void *p);
   static void streamer_TGComboBoxPopup(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGComboBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGComboBox(void *p = 0);
   static void *newArray_TGComboBox(Long_t size, void *p);
   static void delete_TGComboBox(void *p);
   static void deleteArray_TGComboBox(void *p);
   static void destruct_TGComboBox(void *p);
   static void streamer_TGComboBox(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLineStyleComboBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLineStyleComboBox(void *p = 0);
   static void *newArray_TGLineStyleComboBox(Long_t size, void *p);
   static void delete_TGLineStyleComboBox(void *p);
   static void deleteArray_TGLineStyleComboBox(void *p);
   static void destruct_TGLineStyleComboBox(void *p);
   static void streamer_TGLineStyleComboBox(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLineStyleComboBox*)
   {
      ::TGLineStyleComboBox *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLineStyleComboBox >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLineStyleComboBox", ::TGLineStyleComboBox::Class_Version(), "include/TGComboBox.h", 156,
                  typeid(::TGLineStyleComboBox), DefineBehavior(ptr, ptr),
                  &::TGLineStyleComboBox::Dictionary, isa_proxy, 0,
                  sizeof(::TGLineStyleComboBox) );
      instance.SetNew(&new_TGLineStyleComboBox);
      instance.SetNewArray(&newArray_TGLineStyleComboBox);
      instance.SetDelete(&delete_TGLineStyleComboBox);
      instance.SetDeleteArray(&deleteArray_TGLineStyleComboBox);
      instance.SetDestructor(&destruct_TGLineStyleComboBox);
      instance.SetStreamerFunc(&streamer_TGLineStyleComboBox);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLineStyleComboBox*)
   {
      return GenerateInitInstanceLocal((::TGLineStyleComboBox*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLineStyleComboBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLineWidthComboBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLineWidthComboBox(void *p = 0);
   static void *newArray_TGLineWidthComboBox(Long_t size, void *p);
   static void delete_TGLineWidthComboBox(void *p);
   static void deleteArray_TGLineWidthComboBox(void *p);
   static void destruct_TGLineWidthComboBox(void *p);
   static void streamer_TGLineWidthComboBox(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLineWidthComboBox*)
   {
      ::TGLineWidthComboBox *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLineWidthComboBox >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLineWidthComboBox", ::TGLineWidthComboBox::Class_Version(), "include/TGComboBox.h", 178,
                  typeid(::TGLineWidthComboBox), DefineBehavior(ptr, ptr),
                  &::TGLineWidthComboBox::Dictionary, isa_proxy, 0,
                  sizeof(::TGLineWidthComboBox) );
      instance.SetNew(&new_TGLineWidthComboBox);
      instance.SetNewArray(&newArray_TGLineWidthComboBox);
      instance.SetDelete(&delete_TGLineWidthComboBox);
      instance.SetDeleteArray(&deleteArray_TGLineWidthComboBox);
      instance.SetDestructor(&destruct_TGLineWidthComboBox);
      instance.SetStreamerFunc(&streamer_TGLineWidthComboBox);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLineWidthComboBox*)
   {
      return GenerateInitInstanceLocal((::TGLineWidthComboBox*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLineWidthComboBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFontTypeComboBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFontTypeComboBox(void *p = 0);
   static void *newArray_TGFontTypeComboBox(Long_t size, void *p);
   static void delete_TGFontTypeComboBox(void *p);
   static void deleteArray_TGFontTypeComboBox(void *p);
   static void destruct_TGFontTypeComboBox(void *p);
   static void streamer_TGFontTypeComboBox(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFontTypeComboBox*)
   {
      ::TGFontTypeComboBox *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGFontTypeComboBox >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFontTypeComboBox", ::TGFontTypeComboBox::Class_Version(), "include/TGComboBox.h", 202,
                  typeid(::TGFontTypeComboBox), DefineBehavior(ptr, ptr),
                  &::TGFontTypeComboBox::Dictionary, isa_proxy, 0,
                  sizeof(::TGFontTypeComboBox) );
      instance.SetNew(&new_TGFontTypeComboBox);
      instance.SetNewArray(&newArray_TGFontTypeComboBox);
      instance.SetDelete(&delete_TGFontTypeComboBox);
      instance.SetDeleteArray(&deleteArray_TGFontTypeComboBox);
      instance.SetDestructor(&destruct_TGFontTypeComboBox);
      instance.SetStreamerFunc(&streamer_TGFontTypeComboBox);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFontTypeComboBox*)
   {
      return GenerateInitInstanceLocal((::TGFontTypeComboBox*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFontTypeComboBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTabElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTabElement(void *p = 0);
   static void *newArray_TGTabElement(Long_t size, void *p);
   static void delete_TGTabElement(void *p);
   static void deleteArray_TGTabElement(void *p);
   static void destruct_TGTabElement(void *p);
   static void streamer_TGTabElement(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTabElement*)
   {
      ::TGTabElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTabElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTabElement", ::TGTabElement::Class_Version(), "include/TGTab.h", 134,
                  typeid(::TGTabElement), DefineBehavior(ptr, ptr),
                  &::TGTabElement::Dictionary, isa_proxy, 0,
                  sizeof(::TGTabElement) );
      instance.SetNew(&new_TGTabElement);
      instance.SetNewArray(&newArray_TGTabElement);
      instance.SetDelete(&delete_TGTabElement);
      instance.SetDeleteArray(&deleteArray_TGTabElement);
      instance.SetDestructor(&destruct_TGTabElement);
      instance.SetStreamerFunc(&streamer_TGTabElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTabElement*)
   {
      return GenerateInitInstanceLocal((::TGTabElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTabElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTab_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTab(void *p = 0);
   static void *newArray_TGTab(Long_t size, void *p);
   static void delete_TGTab(void *p);
   static void deleteArray_TGTab(void *p);
   static void destruct_TGTab(void *p);
   static void streamer_TGTab(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTab*)
   {
      ::TGTab *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTab >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTab", ::TGTab::Class_Version(), "include/TGTab.h", 66,
                  typeid(::TGTab), DefineBehavior(ptr, ptr),
                  &::TGTab::Dictionary, isa_proxy, 0,
                  sizeof(::TGTab) );
      instance.SetNew(&new_TGTab);
      instance.SetNewArray(&newArray_TGTab);
      instance.SetDelete(&delete_TGTab);
      instance.SetDeleteArray(&deleteArray_TGTab);
      instance.SetDestructor(&destruct_TGTab);
      instance.SetStreamerFunc(&streamer_TGTab);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTab*)
   {
      return GenerateInitInstanceLocal((::TGTab*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTab*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTabLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGTabLayout(void *p);
   static void deleteArray_TGTabLayout(void *p);
   static void destruct_TGTabLayout(void *p);
   static void streamer_TGTabLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGSlider(void *p);
   static void deleteArray_TGSlider(void *p);
   static void destruct_TGSlider(void *p);
   static void streamer_TGSlider(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGVSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVSlider(void *p = 0);
   static void *newArray_TGVSlider(Long_t size, void *p);
   static void delete_TGVSlider(void *p);
   static void deleteArray_TGVSlider(void *p);
   static void destruct_TGVSlider(void *p);
   static void streamer_TGVSlider(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVSlider*)
   {
      ::TGVSlider *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVSlider >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVSlider", ::TGVSlider::Class_Version(), "include/TGSlider.h", 125,
                  typeid(::TGVSlider), DefineBehavior(ptr, ptr),
                  &::TGVSlider::Dictionary, isa_proxy, 0,
                  sizeof(::TGVSlider) );
      instance.SetNew(&new_TGVSlider);
      instance.SetNewArray(&newArray_TGVSlider);
      instance.SetDelete(&delete_TGVSlider);
      instance.SetDeleteArray(&deleteArray_TGVSlider);
      instance.SetDestructor(&destruct_TGVSlider);
      instance.SetStreamerFunc(&streamer_TGVSlider);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVSlider*)
   {
      return GenerateInitInstanceLocal((::TGVSlider*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVSlider*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGHSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHSlider(void *p = 0);
   static void *newArray_TGHSlider(Long_t size, void *p);
   static void delete_TGHSlider(void *p);
   static void deleteArray_TGHSlider(void *p);
   static void destruct_TGHSlider(void *p);
   static void streamer_TGHSlider(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSplitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGSplitter(void *p);
   static void deleteArray_TGSplitter(void *p);
   static void destruct_TGSplitter(void *p);
   static void streamer_TGSplitter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGVSplitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGVSplitter(void *p = 0);
   static void *newArray_TGVSplitter(Long_t size, void *p);
   static void delete_TGVSplitter(void *p);
   static void deleteArray_TGVSplitter(void *p);
   static void destruct_TGVSplitter(void *p);
   static void streamer_TGVSplitter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGVSplitter*)
   {
      ::TGVSplitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGVSplitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGVSplitter", ::TGVSplitter::Class_Version(), "include/TGSplitter.h", 65,
                  typeid(::TGVSplitter), DefineBehavior(ptr, ptr),
                  &::TGVSplitter::Dictionary, isa_proxy, 0,
                  sizeof(::TGVSplitter) );
      instance.SetNew(&new_TGVSplitter);
      instance.SetNewArray(&newArray_TGVSplitter);
      instance.SetDelete(&delete_TGVSplitter);
      instance.SetDeleteArray(&deleteArray_TGVSplitter);
      instance.SetDestructor(&destruct_TGVSplitter);
      instance.SetStreamerFunc(&streamer_TGVSplitter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGVSplitter*)
   {
      return GenerateInitInstanceLocal((::TGVSplitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGVSplitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGHSplitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGHSplitter(void *p = 0);
   static void *newArray_TGHSplitter(Long_t size, void *p);
   static void delete_TGHSplitter(void *p);
   static void deleteArray_TGHSplitter(void *p);
   static void destruct_TGHSplitter(void *p);
   static void streamer_TGHSplitter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGHSplitter*)
   {
      ::TGHSplitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGHSplitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGHSplitter", ::TGHSplitter::Class_Version(), "include/TGSplitter.h", 102,
                  typeid(::TGHSplitter), DefineBehavior(ptr, ptr),
                  &::TGHSplitter::Dictionary, isa_proxy, 0,
                  sizeof(::TGHSplitter) );
      instance.SetNew(&new_TGHSplitter);
      instance.SetNewArray(&newArray_TGHSplitter);
      instance.SetDelete(&delete_TGHSplitter);
      instance.SetDeleteArray(&deleteArray_TGHSplitter);
      instance.SetDestructor(&destruct_TGHSplitter);
      instance.SetStreamerFunc(&streamer_TGHSplitter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGHSplitter*)
   {
      return GenerateInitInstanceLocal((::TGHSplitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGHSplitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLVContainer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLVContainer(void *p);
   static void deleteArray_TGLVContainer(void *p);
   static void destruct_TGLVContainer(void *p);
   static void streamer_TGLVContainer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLVEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLVEntry(void *p = 0);
   static void *newArray_TGLVEntry(Long_t size, void *p);
   static void delete_TGLVEntry(void *p);
   static void deleteArray_TGLVEntry(void *p);
   static void destruct_TGLVEntry(void *p);
   static void streamer_TGLVEntry(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLVEntry*)
   {
      ::TGLVEntry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLVEntry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLVEntry", ::TGLVEntry::Class_Version(), "include/TGListView.h", 60,
                  typeid(::TGLVEntry), DefineBehavior(ptr, ptr),
                  &::TGLVEntry::Dictionary, isa_proxy, 0,
                  sizeof(::TGLVEntry) );
      instance.SetNew(&new_TGLVEntry);
      instance.SetNewArray(&newArray_TGLVEntry);
      instance.SetDelete(&delete_TGLVEntry);
      instance.SetDeleteArray(&deleteArray_TGLVEntry);
      instance.SetDestructor(&destruct_TGLVEntry);
      instance.SetStreamerFunc(&streamer_TGLVEntry);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLVEntry*)
   {
      return GenerateInitInstanceLocal((::TGLVEntry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLVEntry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFileContainer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFileContainer(void *p = 0);
   static void *newArray_TGFileContainer(Long_t size, void *p);
   static void delete_TGFileContainer(void *p);
   static void deleteArray_TGFileContainer(void *p);
   static void destruct_TGFileContainer(void *p);
   static void streamer_TGFileContainer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFileContainer*)
   {
      ::TGFileContainer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGFileContainer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFileContainer", ::TGFileContainer::Class_Version(), "include/TGFSContainer.h", 147,
                  typeid(::TGFileContainer), DefineBehavior(ptr, ptr),
                  &::TGFileContainer::Dictionary, isa_proxy, 0,
                  sizeof(::TGFileContainer) );
      instance.SetNew(&new_TGFileContainer);
      instance.SetNewArray(&newArray_TGFileContainer);
      instance.SetDelete(&delete_TGFileContainer);
      instance.SetDeleteArray(&deleteArray_TGFileContainer);
      instance.SetDestructor(&destruct_TGFileContainer);
      instance.SetStreamerFunc(&streamer_TGFileContainer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFileContainer*)
   {
      return GenerateInitInstanceLocal((::TGFileContainer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFileContainer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGFileItem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFileItem(void *p = 0);
   static void *newArray_TGFileItem(Long_t size, void *p);
   static void delete_TGFileItem(void *p);
   static void deleteArray_TGFileItem(void *p);
   static void destruct_TGFileItem(void *p);
   static void streamer_TGFileItem(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGFSComboBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFSComboBox(void *p = 0);
   static void *newArray_TGFSComboBox(Long_t size, void *p);
   static void delete_TGFSComboBox(void *p);
   static void deleteArray_TGFSComboBox(void *p);
   static void destruct_TGFSComboBox(void *p);
   static void streamer_TGFSComboBox(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGFileInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGFileInfo_Dictionary();
   static void *new_TGFileInfo(void *p = 0);
   static void *newArray_TGFileInfo(Long_t size, void *p);
   static void delete_TGFileInfo(void *p);
   static void deleteArray_TGFileInfo(void *p);
   static void destruct_TGFileInfo(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFileInfo*)
   {
      ::TGFileInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGFileInfo),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFileInfo", "include/TGFileDialog.h", 56,
                  typeid(::TGFileInfo), DefineBehavior(ptr, ptr),
                  0, &TGFileInfo_Dictionary, isa_proxy, 0,
                  sizeof(::TGFileInfo) );
      instance.SetNew(&new_TGFileInfo);
      instance.SetNewArray(&newArray_TGFileInfo);
      instance.SetDelete(&delete_TGFileInfo);
      instance.SetDeleteArray(&deleteArray_TGFileInfo);
      instance.SetDestructor(&destruct_TGFileInfo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFileInfo*)
   {
      return GenerateInitInstanceLocal((::TGFileInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFileInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGFileDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGFileDialog(void *p = 0);
   static void *newArray_TGFileDialog(Long_t size, void *p);
   static void delete_TGFileDialog(void *p);
   static void deleteArray_TGFileDialog(void *p);
   static void destruct_TGFileDialog(void *p);
   static void streamer_TGFileDialog(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGFileDialog*)
   {
      ::TGFileDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGFileDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGFileDialog", ::TGFileDialog::Class_Version(), "include/TGFileDialog.h", 79,
                  typeid(::TGFileDialog), DefineBehavior(ptr, ptr),
                  &::TGFileDialog::Dictionary, isa_proxy, 0,
                  sizeof(::TGFileDialog) );
      instance.SetNew(&new_TGFileDialog);
      instance.SetNewArray(&newArray_TGFileDialog);
      instance.SetDelete(&delete_TGFileDialog);
      instance.SetDeleteArray(&deleteArray_TGFileDialog);
      instance.SetDestructor(&destruct_TGFileDialog);
      instance.SetStreamerFunc(&streamer_TGFileDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGFileDialog*)
   {
      return GenerateInitInstanceLocal((::TGFileDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGFileDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGStatusBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGStatusBar(void *p = 0);
   static void *newArray_TGStatusBar(Long_t size, void *p);
   static void delete_TGStatusBar(void *p);
   static void deleteArray_TGStatusBar(void *p);
   static void destruct_TGStatusBar(void *p);
   static void streamer_TGStatusBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void ToolBarData_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ToolBarData_t_Dictionary();
   static void *new_ToolBarData_t(void *p = 0);
   static void *newArray_ToolBarData_t(Long_t size, void *p);
   static void delete_ToolBarData_t(void *p);
   static void deleteArray_ToolBarData_t(void *p);
   static void destruct_ToolBarData_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ToolBarData_t*)
   {
      ::ToolBarData_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ToolBarData_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("ToolBarData_t", "include/TGToolBar.h", 34,
                  typeid(::ToolBarData_t), DefineBehavior(ptr, ptr),
                  0, &ToolBarData_t_Dictionary, isa_proxy, 0,
                  sizeof(::ToolBarData_t) );
      instance.SetNew(&new_ToolBarData_t);
      instance.SetNewArray(&newArray_ToolBarData_t);
      instance.SetDelete(&delete_ToolBarData_t);
      instance.SetDeleteArray(&deleteArray_ToolBarData_t);
      instance.SetDestructor(&destruct_ToolBarData_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ToolBarData_t*)
   {
      return GenerateInitInstanceLocal((::ToolBarData_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ToolBarData_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGToolBar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGToolBar(void *p = 0);
   static void *newArray_TGToolBar(Long_t size, void *p);
   static void delete_TGToolBar(void *p);
   static void deleteArray_TGToolBar(void *p);
   static void destruct_TGToolBar(void *p);
   static void streamer_TGToolBar(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGListTreeItem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGListTreeItem(void *p);
   static void deleteArray_TGListTreeItem(void *p);
   static void destruct_TGListTreeItem(void *p);
   static void streamer_TGListTreeItem(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGListTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGListTree(void *p = 0);
   static void *newArray_TGListTree(Long_t size, void *p);
   static void delete_TGListTree(void *p);
   static void deleteArray_TGListTree(void *p);
   static void destruct_TGListTree(void *p);
   static void streamer_TGListTree(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGListTree*)
   {
      ::TGListTree *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGListTree >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGListTree", ::TGListTree::Class_Version(), "include/TGListTree.h", 216,
                  typeid(::TGListTree), DefineBehavior(ptr, ptr),
                  &::TGListTree::Dictionary, isa_proxy, 0,
                  sizeof(::TGListTree) );
      instance.SetNew(&new_TGListTree);
      instance.SetNewArray(&newArray_TGListTree);
      instance.SetDelete(&delete_TGListTree);
      instance.SetDeleteArray(&deleteArray_TGListTree);
      instance.SetDestructor(&destruct_TGListTree);
      instance.SetStreamerFunc(&streamer_TGListTree);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGListTree*)
   {
      return GenerateInitInstanceLocal((::TGListTree*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGListTree*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGListTreeItemStd_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGListTreeItemStd(void *p = 0);
   static void *newArray_TGListTreeItemStd(Long_t size, void *p);
   static void delete_TGListTreeItemStd(void *p);
   static void deleteArray_TGListTreeItemStd(void *p);
   static void destruct_TGListTreeItemStd(void *p);
   static void streamer_TGListTreeItemStd(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGListTreeItemStd*)
   {
      ::TGListTreeItemStd *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGListTreeItemStd >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGListTreeItemStd", ::TGListTreeItemStd::Class_Version(), "include/TGListTree.h", 148,
                  typeid(::TGListTreeItemStd), DefineBehavior(ptr, ptr),
                  &::TGListTreeItemStd::Dictionary, isa_proxy, 0,
                  sizeof(::TGListTreeItemStd) );
      instance.SetNew(&new_TGListTreeItemStd);
      instance.SetNewArray(&newArray_TGListTreeItemStd);
      instance.SetDelete(&delete_TGListTreeItemStd);
      instance.SetDeleteArray(&deleteArray_TGListTreeItemStd);
      instance.SetDestructor(&destruct_TGListTreeItemStd);
      instance.SetStreamerFunc(&streamer_TGListTreeItemStd);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGListTreeItemStd*)
   {
      return GenerateInitInstanceLocal((::TGListTreeItemStd*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGListTreeItemStd*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTextLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextLine(void *p = 0);
   static void *newArray_TGTextLine(Long_t size, void *p);
   static void delete_TGTextLine(void *p);
   static void deleteArray_TGTextLine(void *p);
   static void destruct_TGTextLine(void *p);
   static void streamer_TGTextLine(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGText(void *p = 0);
   static void *newArray_TGText(Long_t size, void *p);
   static void delete_TGText(void *p);
   static void deleteArray_TGText(void *p);
   static void destruct_TGText(void *p);
   static void streamer_TGText(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGViewFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGViewFrame(void *p);
   static void deleteArray_TGViewFrame(void *p);
   static void destruct_TGViewFrame(void *p);
   static void streamer_TGViewFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGView_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGView(void *p = 0);
   static void *newArray_TGView(Long_t size, void *p);
   static void delete_TGView(void *p);
   static void deleteArray_TGView(void *p);
   static void destruct_TGView(void *p);
   static void streamer_TGView(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTextView_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextView(void *p = 0);
   static void *newArray_TGTextView(Long_t size, void *p);
   static void delete_TGTextView(void *p);
   static void deleteArray_TGTextView(void *p);
   static void destruct_TGTextView(void *p);
   static void streamer_TGTextView(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSearchType_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGSearchType_Dictionary();
   static void *new_TGSearchType(void *p = 0);
   static void *newArray_TGSearchType(Long_t size, void *p);
   static void delete_TGSearchType(void *p);
   static void deleteArray_TGSearchType(void *p);
   static void destruct_TGSearchType(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGSearchType*)
   {
      ::TGSearchType *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGSearchType),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGSearchType", "include/TGTextEditDialogs.h", 32,
                  typeid(::TGSearchType), DefineBehavior(ptr, ptr),
                  0, &TGSearchType_Dictionary, isa_proxy, 0,
                  sizeof(::TGSearchType) );
      instance.SetNew(&new_TGSearchType);
      instance.SetNewArray(&newArray_TGSearchType);
      instance.SetDelete(&delete_TGSearchType);
      instance.SetDeleteArray(&deleteArray_TGSearchType);
      instance.SetDestructor(&destruct_TGSearchType);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGSearchType*)
   {
      return GenerateInitInstanceLocal((::TGSearchType*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGSearchType*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGTextEdit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTextEdit(void *p = 0);
   static void *newArray_TGTextEdit(Long_t size, void *p);
   static void delete_TGTextEdit(void *p);
   static void deleteArray_TGTextEdit(void *p);
   static void destruct_TGTextEdit(void *p);
   static void streamer_TGTextEdit(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGSearchDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGSearchDialog(void *p = 0);
   static void *newArray_TGSearchDialog(Long_t size, void *p);
   static void delete_TGSearchDialog(void *p);
   static void deleteArray_TGSearchDialog(void *p);
   static void destruct_TGSearchDialog(void *p);
   static void streamer_TGSearchDialog(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGSearchDialog*)
   {
      ::TGSearchDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGSearchDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGSearchDialog", ::TGSearchDialog::Class_Version(), "include/TGTextEditDialogs.h", 51,
                  typeid(::TGSearchDialog), DefineBehavior(ptr, ptr),
                  &::TGSearchDialog::Dictionary, isa_proxy, 0,
                  sizeof(::TGSearchDialog) );
      instance.SetNew(&new_TGSearchDialog);
      instance.SetNewArray(&newArray_TGSearchDialog);
      instance.SetDelete(&delete_TGSearchDialog);
      instance.SetDeleteArray(&deleteArray_TGSearchDialog);
      instance.SetDestructor(&destruct_TGSearchDialog);
      instance.SetStreamerFunc(&streamer_TGSearchDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGSearchDialog*)
   {
      return GenerateInitInstanceLocal((::TGSearchDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGSearchDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGPrintDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGPrintDialog(void *p = 0);
   static void *newArray_TGPrintDialog(Long_t size, void *p);
   static void delete_TGPrintDialog(void *p);
   static void deleteArray_TGPrintDialog(void *p);
   static void destruct_TGPrintDialog(void *p);
   static void streamer_TGPrintDialog(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGPrintDialog*)
   {
      ::TGPrintDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGPrintDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGPrintDialog", ::TGPrintDialog::Class_Version(), "include/TGTextEditDialogs.h", 91,
                  typeid(::TGPrintDialog), DefineBehavior(ptr, ptr),
                  &::TGPrintDialog::Dictionary, isa_proxy, 0,
                  sizeof(::TGPrintDialog) );
      instance.SetNew(&new_TGPrintDialog);
      instance.SetNewArray(&newArray_TGPrintDialog);
      instance.SetDelete(&delete_TGPrintDialog);
      instance.SetDeleteArray(&deleteArray_TGPrintDialog);
      instance.SetDestructor(&destruct_TGPrintDialog);
      instance.SetStreamerFunc(&streamer_TGPrintDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGPrintDialog*)
   {
      return GenerateInitInstanceLocal((::TGPrintDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGPrintDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGGotoDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGGotoDialog(void *p = 0);
   static void *newArray_TGGotoDialog(Long_t size, void *p);
   static void delete_TGGotoDialog(void *p);
   static void deleteArray_TGGotoDialog(void *p);
   static void destruct_TGGotoDialog(void *p);
   static void streamer_TGGotoDialog(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGGotoDialog*)
   {
      ::TGGotoDialog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGGotoDialog >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGGotoDialog", ::TGGotoDialog::Class_Version(), "include/TGTextEditDialogs.h", 121,
                  typeid(::TGGotoDialog), DefineBehavior(ptr, ptr),
                  &::TGGotoDialog::Dictionary, isa_proxy, 0,
                  sizeof(::TGGotoDialog) );
      instance.SetNew(&new_TGGotoDialog);
      instance.SetNewArray(&newArray_TGGotoDialog);
      instance.SetDelete(&delete_TGGotoDialog);
      instance.SetDeleteArray(&deleteArray_TGGotoDialog);
      instance.SetDestructor(&destruct_TGGotoDialog);
      instance.SetStreamerFunc(&streamer_TGGotoDialog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGGotoDialog*)
   {
      return GenerateInitInstanceLocal((::TGGotoDialog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGGotoDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGDoubleSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGDoubleSlider(void *p);
   static void deleteArray_TGDoubleSlider(void *p);
   static void destruct_TGDoubleSlider(void *p);
   static void streamer_TGDoubleSlider(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGDoubleVSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGDoubleVSlider(void *p = 0);
   static void *newArray_TGDoubleVSlider(Long_t size, void *p);
   static void delete_TGDoubleVSlider(void *p);
   static void deleteArray_TGDoubleVSlider(void *p);
   static void destruct_TGDoubleVSlider(void *p);
   static void streamer_TGDoubleVSlider(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGDoubleVSlider*)
   {
      ::TGDoubleVSlider *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGDoubleVSlider >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGDoubleVSlider", ::TGDoubleVSlider::Class_Version(), "include/TGDoubleSlider.h", 158,
                  typeid(::TGDoubleVSlider), DefineBehavior(ptr, ptr),
                  &::TGDoubleVSlider::Dictionary, isa_proxy, 0,
                  sizeof(::TGDoubleVSlider) );
      instance.SetNew(&new_TGDoubleVSlider);
      instance.SetNewArray(&newArray_TGDoubleVSlider);
      instance.SetDelete(&delete_TGDoubleVSlider);
      instance.SetDeleteArray(&deleteArray_TGDoubleVSlider);
      instance.SetDestructor(&destruct_TGDoubleVSlider);
      instance.SetStreamerFunc(&streamer_TGDoubleVSlider);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGDoubleVSlider*)
   {
      return GenerateInitInstanceLocal((::TGDoubleVSlider*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGDoubleVSlider*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGDoubleHSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGDoubleHSlider(void *p = 0);
   static void *newArray_TGDoubleHSlider(Long_t size, void *p);
   static void delete_TGDoubleHSlider(void *p);
   static void deleteArray_TGDoubleHSlider(void *p);
   static void destruct_TGDoubleHSlider(void *p);
   static void streamer_TGDoubleHSlider(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGDoubleHSlider*)
   {
      ::TGDoubleHSlider *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGDoubleHSlider >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGDoubleHSlider", ::TGDoubleHSlider::Class_Version(), "include/TGDoubleSlider.h", 184,
                  typeid(::TGDoubleHSlider), DefineBehavior(ptr, ptr),
                  &::TGDoubleHSlider::Dictionary, isa_proxy, 0,
                  sizeof(::TGDoubleHSlider) );
      instance.SetNew(&new_TGDoubleHSlider);
      instance.SetNewArray(&newArray_TGDoubleHSlider);
      instance.SetDelete(&delete_TGDoubleHSlider);
      instance.SetDeleteArray(&deleteArray_TGDoubleHSlider);
      instance.SetDestructor(&destruct_TGDoubleHSlider);
      instance.SetStreamerFunc(&streamer_TGDoubleHSlider);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGDoubleHSlider*)
   {
      return GenerateInitInstanceLocal((::TGDoubleHSlider*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGDoubleHSlider*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTreeLBEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTreeLBEntry(void *p = 0);
   static void *newArray_TGTreeLBEntry(Long_t size, void *p);
   static void delete_TGTreeLBEntry(void *p);
   static void deleteArray_TGTreeLBEntry(void *p);
   static void destruct_TGTreeLBEntry(void *p);
   static void streamer_TGTreeLBEntry(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGRegion_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGRegion(void *p = 0);
   static void *newArray_TGRegion(Long_t size, void *p);
   static void delete_TGRegion(void *p);
   static void deleteArray_TGRegion(void *p);
   static void destruct_TGRegion(void *p);
   static void streamer_TGRegion(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGRegionWithId_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGRegionWithId(void *p = 0);
   static void *newArray_TGRegionWithId(Long_t size, void *p);
   static void delete_TGRegionWithId(void *p);
   static void deleteArray_TGRegionWithId(void *p);
   static void destruct_TGRegionWithId(void *p);
   static void streamer_TGRegionWithId(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGRegionWithId*)
   {
      ::TGRegionWithId *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGRegionWithId >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGRegionWithId", ::TGRegionWithId::Class_Version(), "include/TGImageMap.h", 83,
                  typeid(::TGRegionWithId), DefineBehavior(ptr, ptr),
                  &::TGRegionWithId::Dictionary, isa_proxy, 0,
                  sizeof(::TGRegionWithId) );
      instance.SetNew(&new_TGRegionWithId);
      instance.SetNewArray(&newArray_TGRegionWithId);
      instance.SetDelete(&delete_TGRegionWithId);
      instance.SetDeleteArray(&deleteArray_TGRegionWithId);
      instance.SetDestructor(&destruct_TGRegionWithId);
      instance.SetStreamerFunc(&streamer_TGRegionWithId);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGRegionWithId*)
   {
      return GenerateInitInstanceLocal((::TGRegionWithId*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGRegionWithId*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGImageMap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGImageMap(void *p = 0);
   static void *newArray_TGImageMap(Long_t size, void *p);
   static void delete_TGImageMap(void *p);
   static void deleteArray_TGImageMap(void *p);
   static void destruct_TGImageMap(void *p);
   static void streamer_TGImageMap(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGImageMap*)
   {
      ::TGImageMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGImageMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGImageMap", ::TGImageMap::Class_Version(), "include/TGImageMap.h", 115,
                  typeid(::TGImageMap), DefineBehavior(ptr, ptr),
                  &::TGImageMap::Dictionary, isa_proxy, 0,
                  sizeof(::TGImageMap) );
      instance.SetNew(&new_TGImageMap);
      instance.SetNewArray(&newArray_TGImageMap);
      instance.SetDelete(&delete_TGImageMap);
      instance.SetDeleteArray(&deleteArray_TGImageMap);
      instance.SetDestructor(&destruct_TGImageMap);
      instance.SetStreamerFunc(&streamer_TGImageMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGImageMap*)
   {
      return GenerateInitInstanceLocal((::TGImageMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGImageMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGApplication_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGApplication(void *p);
   static void deleteArray_TGApplication(void *p);
   static void destruct_TGApplication(void *p);
   static void streamer_TGApplication(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGXYLayoutHints_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGXYLayoutHints(void *p);
   static void deleteArray_TGXYLayoutHints(void *p);
   static void destruct_TGXYLayoutHints(void *p);
   static void streamer_TGXYLayoutHints(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGXYLayout_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGXYLayout(void *p);
   static void deleteArray_TGXYLayout(void *p);
   static void destruct_TGXYLayout(void *p);
   static void streamer_TGXYLayout(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGTripleVSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTripleVSlider(void *p = 0);
   static void *newArray_TGTripleVSlider(Long_t size, void *p);
   static void delete_TGTripleVSlider(void *p);
   static void deleteArray_TGTripleVSlider(void *p);
   static void destruct_TGTripleVSlider(void *p);
   static void streamer_TGTripleVSlider(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTripleVSlider*)
   {
      ::TGTripleVSlider *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTripleVSlider >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTripleVSlider", ::TGTripleVSlider::Class_Version(), "include/TGTripleSlider.h", 66,
                  typeid(::TGTripleVSlider), DefineBehavior(ptr, ptr),
                  &::TGTripleVSlider::Dictionary, isa_proxy, 0,
                  sizeof(::TGTripleVSlider) );
      instance.SetNew(&new_TGTripleVSlider);
      instance.SetNewArray(&newArray_TGTripleVSlider);
      instance.SetDelete(&delete_TGTripleVSlider);
      instance.SetDeleteArray(&deleteArray_TGTripleVSlider);
      instance.SetDestructor(&destruct_TGTripleVSlider);
      instance.SetStreamerFunc(&streamer_TGTripleVSlider);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTripleVSlider*)
   {
      return GenerateInitInstanceLocal((::TGTripleVSlider*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTripleVSlider*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGTripleHSlider_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGTripleHSlider(void *p = 0);
   static void *newArray_TGTripleHSlider(Long_t size, void *p);
   static void delete_TGTripleHSlider(void *p);
   static void deleteArray_TGTripleHSlider(void *p);
   static void destruct_TGTripleHSlider(void *p);
   static void streamer_TGTripleHSlider(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTripleHSlider*)
   {
      ::TGTripleHSlider *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTripleHSlider >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGTripleHSlider", ::TGTripleHSlider::Class_Version(), "include/TGTripleSlider.h", 107,
                  typeid(::TGTripleHSlider), DefineBehavior(ptr, ptr),
                  &::TGTripleHSlider::Dictionary, isa_proxy, 0,
                  sizeof(::TGTripleHSlider) );
      instance.SetNew(&new_TGTripleHSlider);
      instance.SetNewArray(&newArray_TGTripleHSlider);
      instance.SetDelete(&delete_TGTripleHSlider);
      instance.SetDeleteArray(&deleteArray_TGTripleHSlider);
      instance.SetDestructor(&destruct_TGTripleHSlider);
      instance.SetStreamerFunc(&streamer_TGTripleHSlider);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGTripleHSlider*)
   {
      return GenerateInitInstanceLocal((::TGTripleHSlider*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTripleHSlider*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGScrollBarElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGScrollBarElement.
      TClass *R__cl = ::TGScrollBarElement::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(), "*fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicN", &fPicN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicD", &fPicD);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGScrollBarElement(void *p) {
      return  p ? new(p) ::TGScrollBarElement : new ::TGScrollBarElement;
   }
   static void *newArray_TGScrollBarElement(Long_t nElements, void *p) {
      return p ? new(p) ::TGScrollBarElement[nElements] : new ::TGScrollBarElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGScrollBarElement(void *p) {
      delete ((::TGScrollBarElement*)p);
   }
   static void deleteArray_TGScrollBarElement(void *p) {
      delete [] ((::TGScrollBarElement*)p);
   }
   static void destruct_TGScrollBarElement(void *p) {
      typedef ::TGScrollBarElement current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGScrollBarElement(TBuffer &buf, void *obj) {
      ((::TGScrollBarElement*)obj)->::TGScrollBarElement::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGScrollBarElement

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

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

//______________________________________________________________________________
void TGScrollBar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGScrollBar.
      TClass *R__cl = ::TGScrollBar::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXp", &fXp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYp", &fYp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragging", &fDragging);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrabPointer", &fGrabPointer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRange", &fRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsize", &fPsize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderSize", &fSliderSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderRange", &fSliderRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmallInc", &fSmallInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHead", &fHead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTail", &fTail);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlider", &fSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeadPic", &fHeadPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTailPic", &fTailPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRepeat", &fRepeat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSubw", &fSubw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAccelerated", &fAccelerated);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

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

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

   TGScrollBar::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHScrollBar(void *p) {
      return  p ? new(p) ::TGHScrollBar : new ::TGHScrollBar;
   }
   static void *newArray_TGHScrollBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGHScrollBar[nElements] : new ::TGHScrollBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHScrollBar(void *p) {
      delete ((::TGHScrollBar*)p);
   }
   static void deleteArray_TGHScrollBar(void *p) {
      delete [] ((::TGHScrollBar*)p);
   }
   static void destruct_TGHScrollBar(void *p) {
      typedef ::TGHScrollBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHScrollBar(TBuffer &buf, void *obj) {
      ((::TGHScrollBar*)obj)->::TGHScrollBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHScrollBar

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

   TGScrollBar::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVScrollBar(void *p) {
      return  p ? new(p) ::TGVScrollBar : new ::TGVScrollBar;
   }
   static void *newArray_TGVScrollBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGVScrollBar[nElements] : new ::TGVScrollBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVScrollBar(void *p) {
      delete ((::TGVScrollBar*)p);
   }
   static void deleteArray_TGVScrollBar(void *p) {
      delete [] ((::TGVScrollBar*)p);
   }
   static void destruct_TGVScrollBar(void *p) {
      typedef ::TGVScrollBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVScrollBar(TBuffer &buf, void *obj) {
      ((::TGVScrollBar*)obj)->::TGVScrollBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVScrollBar

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGViewPort(void *p) {
      return  p ? new(p) ::TGViewPort : new ::TGViewPort;
   }
   static void *newArray_TGViewPort(Long_t nElements, void *p) {
      return p ? new(p) ::TGViewPort[nElements] : new ::TGViewPort[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGViewPort(void *p) {
      delete ((::TGViewPort*)p);
   }
   static void deleteArray_TGViewPort(void *p) {
      delete [] ((::TGViewPort*)p);
   }
   static void destruct_TGViewPort(void *p) {
      typedef ::TGViewPort current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGViewPort(TBuffer &buf, void *obj) {
      ((::TGViewPort*)obj)->::TGViewPort::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGViewPort

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

   TGFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGCanvas(void *p) {
      return  p ? new(p) ::TGCanvas : new ::TGCanvas;
   }
   static void *newArray_TGCanvas(Long_t nElements, void *p) {
      return p ? new(p) ::TGCanvas[nElements] : new ::TGCanvas[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGCanvas(void *p) {
      delete ((::TGCanvas*)p);
   }
   static void deleteArray_TGCanvas(void *p) {
      delete [] ((::TGCanvas*)p);
   }
   static void destruct_TGCanvas(void *p) {
      typedef ::TGCanvas current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGCanvas(TBuffer &buf, void *obj) {
      ((::TGCanvas*)obj)->::TGCanvas::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGCanvas

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGLBEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLBEntry.
      TClass *R__cl = ::TGLBEntry::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(), "fBkcolor", &fBkcolor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLBEntry(void *p) {
      return  p ? new(p) ::TGLBEntry : new ::TGLBEntry;
   }
   static void *newArray_TGLBEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGLBEntry[nElements] : new ::TGLBEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLBEntry(void *p) {
      delete ((::TGLBEntry*)p);
   }
   static void deleteArray_TGLBEntry(void *p) {
      delete [] ((::TGLBEntry*)p);
   }
   static void destruct_TGLBEntry(void *p) {
      typedef ::TGLBEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLBEntry(TBuffer &buf, void *obj) {
      ((::TGLBEntry*)obj)->::TGLBEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLBEntry

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

   TGLBEntry::Streamer(R__b);
}

//______________________________________________________________________________
void TGTextLBEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTextLBEntry.
      TClass *R__cl = ::TGTextLBEntry::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(), "fTextChanged", &fTextChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      TGLBEntry::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextLBEntry(void *p) {
      return  p ? new(p) ::TGTextLBEntry : new ::TGTextLBEntry;
   }
   static void *newArray_TGTextLBEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextLBEntry[nElements] : new ::TGTextLBEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextLBEntry(void *p) {
      delete ((::TGTextLBEntry*)p);
   }
   static void deleteArray_TGTextLBEntry(void *p) {
      delete [] ((::TGTextLBEntry*)p);
   }
   static void destruct_TGTextLBEntry(void *p) {
      typedef ::TGTextLBEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextLBEntry(TBuffer &buf, void *obj) {
      ((::TGTextLBEntry*)obj)->::TGTextLBEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextLBEntry

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

   TGTextLBEntry::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLineLBEntry(void *p) {
      return  p ? new(p) ::TGLineLBEntry : new ::TGLineLBEntry;
   }
   static void *newArray_TGLineLBEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGLineLBEntry[nElements] : new ::TGLineLBEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLineLBEntry(void *p) {
      delete ((::TGLineLBEntry*)p);
   }
   static void deleteArray_TGLineLBEntry(void *p) {
      delete [] ((::TGLineLBEntry*)p);
   }
   static void destruct_TGLineLBEntry(void *p) {
      typedef ::TGLineLBEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLineLBEntry(TBuffer &buf, void *obj) {
      ((::TGLineLBEntry*)obj)->::TGLineLBEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLineLBEntry

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

   TGTextLBEntry::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGIconLBEntry(void *p) {
      return  p ? new(p) ::TGIconLBEntry : new ::TGIconLBEntry;
   }
   static void *newArray_TGIconLBEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGIconLBEntry[nElements] : new ::TGIconLBEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGIconLBEntry(void *p) {
      delete ((::TGIconLBEntry*)p);
   }
   static void deleteArray_TGIconLBEntry(void *p) {
      delete [] ((::TGIconLBEntry*)p);
   }
   static void destruct_TGIconLBEntry(void *p) {
      typedef ::TGIconLBEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGIconLBEntry(TBuffer &buf, void *obj) {
      ((::TGIconLBEntry*)obj)->::TGIconLBEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGIconLBEntry

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

   TGContainer::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLBContainer(void *p) {
      return  p ? new(p) ::TGLBContainer : new ::TGLBContainer;
   }
   static void *newArray_TGLBContainer(Long_t nElements, void *p) {
      return p ? new(p) ::TGLBContainer[nElements] : new ::TGLBContainer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLBContainer(void *p) {
      delete ((::TGLBContainer*)p);
   }
   static void deleteArray_TGLBContainer(void *p) {
      delete [] ((::TGLBContainer*)p);
   }
   static void destruct_TGLBContainer(void *p) {
      typedef ::TGLBContainer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLBContainer(TBuffer &buf, void *obj) {
      ((::TGLBContainer*)obj)->::TGLBContainer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLBContainer

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

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

//______________________________________________________________________________
void TGListBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGListBox.
      TClass *R__cl = ::TGListBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fItemVsize", &fItemVsize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntegralHeight", &fIntegralHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLbc", &fLbc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVport", &fVport);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVScrollbar", &fVScrollbar);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGListBox(void *p) {
      return  p ? new(p) ::TGListBox : new ::TGListBox;
   }
   static void *newArray_TGListBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGListBox[nElements] : new ::TGListBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGListBox(void *p) {
      delete ((::TGListBox*)p);
   }
   static void deleteArray_TGListBox(void *p) {
      delete [] ((::TGListBox*)p);
   }
   static void destruct_TGListBox(void *p) {
      typedef ::TGListBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGListBox(TBuffer &buf, void *obj) {
      ((::TGListBox*)obj)->::TGListBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGListBox

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGComboBoxPopup(void *p) {
      return  p ? new(p) ::TGComboBoxPopup : new ::TGComboBoxPopup;
   }
   static void *newArray_TGComboBoxPopup(Long_t nElements, void *p) {
      return p ? new(p) ::TGComboBoxPopup[nElements] : new ::TGComboBoxPopup[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGComboBoxPopup(void *p) {
      delete ((::TGComboBoxPopup*)p);
   }
   static void deleteArray_TGComboBoxPopup(void *p) {
      delete [] ((::TGComboBoxPopup*)p);
   }
   static void destruct_TGComboBoxPopup(void *p) {
      typedef ::TGComboBoxPopup current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGComboBoxPopup(TBuffer &buf, void *obj) {
      ((::TGComboBoxPopup*)obj)->::TGComboBoxPopup::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGComboBoxPopup

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

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

//______________________________________________________________________________
void TGComboBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGComboBox.
      TClass *R__cl = ::TGComboBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelEntry", &fSelEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextEntry", &fTextEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDDButton", &fDDButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboFrame", &fComboFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListBox", &fListBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBpic", &fBpic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLhs", &fLhs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLhb", &fLhb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLhdd", &fLhdd);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGComboBox(void *p) {
      return  p ? new(p) ::TGComboBox : new ::TGComboBox;
   }
   static void *newArray_TGComboBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGComboBox[nElements] : new ::TGComboBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGComboBox(void *p) {
      delete ((::TGComboBox*)p);
   }
   static void deleteArray_TGComboBox(void *p) {
      delete [] ((::TGComboBox*)p);
   }
   static void destruct_TGComboBox(void *p) {
      typedef ::TGComboBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGComboBox(TBuffer &buf, void *obj) {
      ((::TGComboBox*)obj)->::TGComboBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGComboBox

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

   TGComboBox::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLineStyleComboBox(void *p) {
      return  p ? new(p) ::TGLineStyleComboBox : new ::TGLineStyleComboBox;
   }
   static void *newArray_TGLineStyleComboBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGLineStyleComboBox[nElements] : new ::TGLineStyleComboBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLineStyleComboBox(void *p) {
      delete ((::TGLineStyleComboBox*)p);
   }
   static void deleteArray_TGLineStyleComboBox(void *p) {
      delete [] ((::TGLineStyleComboBox*)p);
   }
   static void destruct_TGLineStyleComboBox(void *p) {
      typedef ::TGLineStyleComboBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLineStyleComboBox(TBuffer &buf, void *obj) {
      ((::TGLineStyleComboBox*)obj)->::TGLineStyleComboBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLineStyleComboBox

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

   TGComboBox::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLineWidthComboBox(void *p) {
      return  p ? new(p) ::TGLineWidthComboBox : new ::TGLineWidthComboBox;
   }
   static void *newArray_TGLineWidthComboBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGLineWidthComboBox[nElements] : new ::TGLineWidthComboBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLineWidthComboBox(void *p) {
      delete ((::TGLineWidthComboBox*)p);
   }
   static void deleteArray_TGLineWidthComboBox(void *p) {
      delete [] ((::TGLineWidthComboBox*)p);
   }
   static void destruct_TGLineWidthComboBox(void *p) {
      typedef ::TGLineWidthComboBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLineWidthComboBox(TBuffer &buf, void *obj) {
      ((::TGLineWidthComboBox*)obj)->::TGLineWidthComboBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLineWidthComboBox

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

   TGComboBox::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFontTypeComboBox(void *p) {
      return  p ? new(p) ::TGFontTypeComboBox : new ::TGFontTypeComboBox;
   }
   static void *newArray_TGFontTypeComboBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGFontTypeComboBox[nElements] : new ::TGFontTypeComboBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFontTypeComboBox(void *p) {
      delete ((::TGFontTypeComboBox*)p);
   }
   static void deleteArray_TGFontTypeComboBox(void *p) {
      delete [] ((::TGFontTypeComboBox*)p);
   }
   static void destruct_TGFontTypeComboBox(void *p) {
      typedef ::TGFontTypeComboBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFontTypeComboBox(TBuffer &buf, void *obj) {
      ((::TGFontTypeComboBox*)obj)->::TGFontTypeComboBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFontTypeComboBox

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

   TGComboBox::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFSComboBox(void *p) {
      return  p ? new(p) ::TGFSComboBox : new ::TGFSComboBox;
   }
   static void *newArray_TGFSComboBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGFSComboBox[nElements] : new ::TGFSComboBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFSComboBox(void *p) {
      delete ((::TGFSComboBox*)p);
   }
   static void deleteArray_TGFSComboBox(void *p) {
      delete [] ((::TGFSComboBox*)p);
   }
   static void destruct_TGFSComboBox(void *p) {
      typedef ::TGFSComboBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFSComboBox(TBuffer &buf, void *obj) {
      ((::TGFSComboBox*)obj)->::TGFSComboBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFSComboBox

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

   TGLBEntry::Streamer(R__b);
}

//______________________________________________________________________________
void TGTreeLBEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTreeLBEntry.
      TClass *R__cl = ::TGTreeLBEntry::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(), "*fPath", &fPath);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPic", &fPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelPic", &fSelPic);
      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(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      TGLBEntry::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTreeLBEntry(void *p) {
      return  p ? new(p) ::TGTreeLBEntry : new ::TGTreeLBEntry;
   }
   static void *newArray_TGTreeLBEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGTreeLBEntry[nElements] : new ::TGTreeLBEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTreeLBEntry(void *p) {
      delete ((::TGTreeLBEntry*)p);
   }
   static void deleteArray_TGTreeLBEntry(void *p) {
      delete [] ((::TGTreeLBEntry*)p);
   }
   static void destruct_TGTreeLBEntry(void *p) {
      typedef ::TGTreeLBEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTreeLBEntry(TBuffer &buf, void *obj) {
      ((::TGTreeLBEntry*)obj)->::TGTreeLBEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTreeLBEntry

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGTabElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTabElement.
      TClass *R__cl = ::TGTabElement::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(), "*fClosePic", &fClosePic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClosePicD", &fClosePicD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      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(), "fEnabled", &fEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowClose", &fShowClose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTabElement(void *p) {
      return  p ? new(p) ::TGTabElement : new ::TGTabElement;
   }
   static void *newArray_TGTabElement(Long_t nElements, void *p) {
      return p ? new(p) ::TGTabElement[nElements] : new ::TGTabElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTabElement(void *p) {
      delete ((::TGTabElement*)p);
   }
   static void deleteArray_TGTabElement(void *p) {
      delete [] ((::TGTabElement*)p);
   }
   static void destruct_TGTabElement(void *p) {
      typedef ::TGTabElement current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTabElement(TBuffer &buf, void *obj) {
      ((::TGTabElement*)obj)->::TGTabElement::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTabElement

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

   TGLayoutManager::Streamer(R__b);
}

//______________________________________________________________________________
void TGTabLayout::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTabLayout.
      TClass *R__cl = ::TGTabLayout::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_TGTabLayout(void *p) {
      delete ((::TGTabLayout*)p);
   }
   static void deleteArray_TGTabLayout(void *p) {
      delete [] ((::TGTabLayout*)p);
   }
   static void destruct_TGTabLayout(void *p) {
      typedef ::TGTabLayout current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTabLayout(TBuffer &buf, void *obj) {
      ((::TGTabLayout*)obj)->::TGTabLayout::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTabLayout

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

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

//______________________________________________________________________________
void TGTab::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTab.
      TClass *R__cl = ::TGTab::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(), "fTabh", &fTabh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContainer", &fContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRemoved", &fRemoved);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTab(void *p) {
      return  p ? new(p) ::TGTab : new ::TGTab;
   }
   static void *newArray_TGTab(Long_t nElements, void *p) {
      return p ? new(p) ::TGTab[nElements] : new ::TGTab[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTab(void *p) {
      delete ((::TGTab*)p);
   }
   static void deleteArray_TGTab(void *p) {
      delete [] ((::TGTab*)p);
   }
   static void destruct_TGTab(void *p) {
      typedef ::TGTab current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTab(TBuffer &buf, void *obj) {
      ((::TGTab*)obj)->::TGTab::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTab

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

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

//______________________________________________________________________________
void TGSlider::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGSlider.
      TClass *R__cl = ::TGSlider::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRelPos", &fRelPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVmin", &fVmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVmax", &fVmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScale", &fScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragging", &fDragging);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderPic", &fSliderPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDisabledPic", &fDisabledPic);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

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

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

   TGSlider::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVSlider(void *p) {
      return  p ? new(p) ::TGVSlider : new ::TGVSlider;
   }
   static void *newArray_TGVSlider(Long_t nElements, void *p) {
      return p ? new(p) ::TGVSlider[nElements] : new ::TGVSlider[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVSlider(void *p) {
      delete ((::TGVSlider*)p);
   }
   static void deleteArray_TGVSlider(void *p) {
      delete [] ((::TGVSlider*)p);
   }
   static void destruct_TGVSlider(void *p) {
      typedef ::TGVSlider current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVSlider(TBuffer &buf, void *obj) {
      ((::TGVSlider*)obj)->::TGVSlider::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVSlider

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

   TGSlider::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHSlider(void *p) {
      return  p ? new(p) ::TGHSlider : new ::TGHSlider;
   }
   static void *newArray_TGHSlider(Long_t nElements, void *p) {
      return p ? new(p) ::TGHSlider[nElements] : new ::TGHSlider[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHSlider(void *p) {
      delete ((::TGHSlider*)p);
   }
   static void deleteArray_TGHSlider(void *p) {
      delete [] ((::TGHSlider*)p);
   }
   static void destruct_TGHSlider(void *p) {
      typedef ::TGHSlider current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHSlider(TBuffer &buf, void *obj) {
      ((::TGHSlider*)obj)->::TGHSlider::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHSlider

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

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

//______________________________________________________________________________
void TGDoubleSlider::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGDoubleSlider.
      TClass *R__cl = ::TGDoubleSlider::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmin", &fSmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmax", &fSmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRelPos", &fRelPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVmin", &fVmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVmax", &fVmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScale", &fScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleType", &fScaleType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPressPoint", &fPressPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPressSmin", &fPressSmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPressSmax", &fPressSmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMove", &fMove);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReversedScale", &fReversedScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkEnds", &fMarkEnds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderPic", &fSliderPic);
      TGFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

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

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

   TGDoubleSlider::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGDoubleVSlider(void *p) {
      return  p ? new(p) ::TGDoubleVSlider : new ::TGDoubleVSlider;
   }
   static void *newArray_TGDoubleVSlider(Long_t nElements, void *p) {
      return p ? new(p) ::TGDoubleVSlider[nElements] : new ::TGDoubleVSlider[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGDoubleVSlider(void *p) {
      delete ((::TGDoubleVSlider*)p);
   }
   static void deleteArray_TGDoubleVSlider(void *p) {
      delete [] ((::TGDoubleVSlider*)p);
   }
   static void destruct_TGDoubleVSlider(void *p) {
      typedef ::TGDoubleVSlider current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGDoubleVSlider(TBuffer &buf, void *obj) {
      ((::TGDoubleVSlider*)obj)->::TGDoubleVSlider::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGDoubleVSlider

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

   TGDoubleSlider::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGDoubleHSlider(void *p) {
      return  p ? new(p) ::TGDoubleHSlider : new ::TGDoubleHSlider;
   }
   static void *newArray_TGDoubleHSlider(Long_t nElements, void *p) {
      return p ? new(p) ::TGDoubleHSlider[nElements] : new ::TGDoubleHSlider[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGDoubleHSlider(void *p) {
      delete ((::TGDoubleHSlider*)p);
   }
   static void deleteArray_TGDoubleHSlider(void *p) {
      delete [] ((::TGDoubleHSlider*)p);
   }
   static void destruct_TGDoubleHSlider(void *p) {
      typedef ::TGDoubleHSlider current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGDoubleHSlider(TBuffer &buf, void *obj) {
      ((::TGDoubleHSlider*)obj)->::TGDoubleHSlider::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGDoubleHSlider

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

   TGDoubleVSlider::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTripleVSlider(void *p) {
      return  p ? new(p) ::TGTripleVSlider : new ::TGTripleVSlider;
   }
   static void *newArray_TGTripleVSlider(Long_t nElements, void *p) {
      return p ? new(p) ::TGTripleVSlider[nElements] : new ::TGTripleVSlider[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTripleVSlider(void *p) {
      delete ((::TGTripleVSlider*)p);
   }
   static void deleteArray_TGTripleVSlider(void *p) {
      delete [] ((::TGTripleVSlider*)p);
   }
   static void destruct_TGTripleVSlider(void *p) {
      typedef ::TGTripleVSlider current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTripleVSlider(TBuffer &buf, void *obj) {
      ((::TGTripleVSlider*)obj)->::TGTripleVSlider::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTripleVSlider

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

   TGDoubleHSlider::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTripleHSlider(void *p) {
      return  p ? new(p) ::TGTripleHSlider : new ::TGTripleHSlider;
   }
   static void *newArray_TGTripleHSlider(Long_t nElements, void *p) {
      return p ? new(p) ::TGTripleHSlider[nElements] : new ::TGTripleHSlider[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTripleHSlider(void *p) {
      delete ((::TGTripleHSlider*)p);
   }
   static void deleteArray_TGTripleHSlider(void *p) {
      delete [] ((::TGTripleHSlider*)p);
   }
   static void destruct_TGTripleHSlider(void *p) {
      typedef ::TGTripleHSlider current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTripleHSlider(TBuffer &buf, void *obj) {
      ((::TGTripleHSlider*)obj)->::TGTripleHSlider::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTripleHSlider

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

   TGFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGLVEntry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLVEntry.
      TClass *R__cl = ::TGLVEntry::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fItemName", &fItemName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSubnames", &fSubnames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCpos", &fCpos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJmode", &fJmode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCtw", &fCtw);
      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(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChecked", &fChecked);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewMode", &fViewMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBigPic", &fBigPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSmallPic", &fSmallPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCheckMark", &fCheckMark);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelPic", &fSelPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUserData", &fUserData);
      TGFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLVEntry(void *p) {
      return  p ? new(p) ::TGLVEntry : new ::TGLVEntry;
   }
   static void *newArray_TGLVEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGLVEntry[nElements] : new ::TGLVEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLVEntry(void *p) {
      delete ((::TGLVEntry*)p);
   }
   static void deleteArray_TGLVEntry(void *p) {
      delete [] ((::TGLVEntry*)p);
   }
   static void destruct_TGLVEntry(void *p) {
      typedef ::TGLVEntry current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLVEntry(TBuffer &buf, void *obj) {
      ((::TGLVEntry*)obj)->::TGLVEntry::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLVEntry

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGContainer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGContainer.
      TClass *R__cl = ::TGContainer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewPort", &fViewPort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastActiveEl", &fLastActiveEl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXp", &fXp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYp", &fYp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXf", &fXf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYf", &fYf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragging", &fDragging);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotal", &fTotal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelected", &fSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScrollTimer", &fScrollTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOnMouseOver", &fOnMouseOver);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastDir", &fLastDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastCase", &fLastCase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastSubstring", &fLastSubstring);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastName", &fLastName);
      R__insp.InspectMember(fLastName, "fLastName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKeyTimer", &fKeyTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeyInput", &fKeyInput);
      R__insp.InspectMember(fKeyInput, "fKeyInput.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeyTimerActive", &fKeyTimerActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScrolling", &fScrolling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXDND", &fXDND);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYDND", &fYDND);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBdown", &fBdown);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExposedRegion", &fExposedRegion);
      R__insp.InspectMember(fExposedRegion, "fExposedRegion.");
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGContainer(void *p) {
      return  p ? new(p) ::TGContainer : new ::TGContainer;
   }
   static void *newArray_TGContainer(Long_t nElements, void *p) {
      return p ? new(p) ::TGContainer[nElements] : new ::TGContainer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGContainer(void *p) {
      delete ((::TGContainer*)p);
   }
   static void deleteArray_TGContainer(void *p) {
      delete [] ((::TGContainer*)p);
   }
   static void destruct_TGContainer(void *p) {
      typedef ::TGContainer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGContainer(TBuffer &buf, void *obj) {
      ((::TGContainer*)obj)->::TGContainer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGContainer

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

   TGContainer::Streamer(R__b);
}

//______________________________________________________________________________
void TGLVContainer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLVContainer.
      TClass *R__cl = ::TGLVContainer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fItemLayout", &fItemLayout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewMode", &fViewMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCpos", &fCpos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJmode", &fJmode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMultiSelect", &fMultiSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListView", &fListView);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastActive", &fLastActive);
      TGContainer::ShowMembers(R__insp);
}

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

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

   TGCanvas::Streamer(R__b);
}

//______________________________________________________________________________
void TGListView::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGListView.
      TClass *R__cl = ::TGListView::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(), "*fColumns", &fColumns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJmode", &fJmode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewMode", &fViewMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSize", &fMaxSize);
      R__insp.InspectMember(fMaxSize, "fMaxSize.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColHeader", &fColHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColNames", &fColNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplitHeader", &fSplitHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormGC", &fNormGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeader", &fHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fJustChanged", &fJustChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinColumnSize", &fMinColumnSize);
      TGCanvas::ShowMembers(R__insp);
}

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

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGMimeTypes::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGMimeTypes.
      TClass *R__cl = ::TGMimeTypes::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(), "fFilename", &fFilename);
      R__insp.InspectMember(fFilename, "fFilename.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanged", &fChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      TObject::ShowMembers(R__insp);
}

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

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

   TGLVEntry::Streamer(R__b);
}

//______________________________________________________________________________
void TGFileItem::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFileItem.
      TClass *R__cl = ::TGFileItem::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBlpic", &fBlpic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlpic", &fSlpic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLcurrent", &fLcurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUid", &fUid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGid", &fGid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLink", &fIsLink);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModTime", &fModTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuf", &fBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDNDData", &fDNDData);
      R__insp.InspectMember(fDNDData, "fDNDData.");
      TGLVEntry::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFileItem(void *p) {
      return  p ? new(p) ::TGFileItem : new ::TGFileItem;
   }
   static void *newArray_TGFileItem(Long_t nElements, void *p) {
      return p ? new(p) ::TGFileItem[nElements] : new ::TGFileItem[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFileItem(void *p) {
      delete ((::TGFileItem*)p);
   }
   static void deleteArray_TGFileItem(void *p) {
      delete [] ((::TGFileItem*)p);
   }
   static void destruct_TGFileItem(void *p) {
      typedef ::TGFileItem current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFileItem(TBuffer &buf, void *obj) {
      ((::TGFileItem*)obj)->::TGFileItem::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFileItem

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

   TGLVContainer::Streamer(R__b);
}

//______________________________________________________________________________
void TGFileContainer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFileContainer.
      TClass *R__cl = ::TGFileContainer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSortType", &fSortType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFilter", &fFilter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefresh", &fRefresh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMtime", &fMtime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirectory", &fDirectory);
      R__insp.InspectMember(fDirectory, "fDirectory.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCleanups", &fCleanups);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFolder_t", &fFolder_t);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFolder_s", &fFolder_s);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApp_t", &fApp_t);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApp_s", &fApp_s);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDoc_t", &fDoc_t);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDoc_s", &fDoc_s);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlink_t", &fSlink_t);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlink_s", &fSlink_s);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCachePictures", &fCachePictures);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisplayStat", &fDisplayStat);
      TGLVContainer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFileContainer(void *p) {
      return  p ? new(p) ::TGFileContainer : new ::TGFileContainer;
   }
   static void *newArray_TGFileContainer(Long_t nElements, void *p) {
      return p ? new(p) ::TGFileContainer[nElements] : new ::TGFileContainer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFileContainer(void *p) {
      delete ((::TGFileContainer*)p);
   }
   static void deleteArray_TGFileContainer(void *p) {
      delete [] ((::TGFileContainer*)p);
   }
   static void destruct_TGFileContainer(void *p) {
      typedef ::TGFileContainer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFileContainer(TBuffer &buf, void *obj) {
      ((::TGFileContainer*)obj)->::TGFileContainer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFileContainer

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGFileDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFileDialog.
      TClass *R__cl = ::TGFileDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTbfname", &fTbfname);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fName", &fName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypes", &fTypes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeLB", &fTreeLB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCdup", &fCdup);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewf", &fNewf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDetails", &fDetails);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCheckB", &fCheckB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPcdup", &fPcdup);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPnewf", &fPnewf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlist", &fPlist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdetails", &fPdetails);
      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(), "*fFv", &fFv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFc", &fFc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileInfo", &fFileInfo);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFileDialog(void *p) {
      return  p ? new(p) ::TGFileDialog : new ::TGFileDialog;
   }
   static void *newArray_TGFileDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGFileDialog[nElements] : new ::TGFileDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFileDialog(void *p) {
      delete ((::TGFileDialog*)p);
   }
   static void deleteArray_TGFileDialog(void *p) {
      delete [] ((::TGFileDialog*)p);
   }
   static void destruct_TGFileDialog(void *p) {
      typedef ::TGFileDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGFileDialog(TBuffer &buf, void *obj) {
      ((::TGFileDialog*)obj)->::TGFileDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGFileDialog

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGFileInfo(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGFileInfo : new ::TGFileInfo;
   }
   static void *newArray_TGFileInfo(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGFileInfo[nElements] : new ::TGFileInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGFileInfo(void *p) {
      delete ((::TGFileInfo*)p);
   }
   static void deleteArray_TGFileInfo(void *p) {
      delete [] ((::TGFileInfo*)p);
   }
   static void destruct_TGFileInfo(void *p) {
      typedef ::TGFileInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGFileInfo

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

   TGHorizontalFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGStatusBar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGStatusBar.
      TClass *R__cl = ::TGStatusBar::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusPart", &fStatusPart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParts", &fParts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpart", &fNpart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYt", &fYt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXt", &fXt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "f3DCorner", &f3DCorner);
      TGHorizontalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGStatusBar(void *p) {
      return  p ? new(p) ::TGStatusBar : new ::TGStatusBar;
   }
   static void *newArray_TGStatusBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGStatusBar[nElements] : new ::TGStatusBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGStatusBar(void *p) {
      delete ((::TGStatusBar*)p);
   }
   static void deleteArray_TGStatusBar(void *p) {
      delete [] ((::TGStatusBar*)p);
   }
   static void destruct_TGStatusBar(void *p) {
      typedef ::TGStatusBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGStatusBar(TBuffer &buf, void *obj) {
      ((::TGStatusBar*)obj)->::TGStatusBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGStatusBar

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

   TGCompositeFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGToolTip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGToolTip.
      TClass *R__cl = ::TGToolTip::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(), "*fL1", &fL1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelay", &fDelay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWindow", &fWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBox", &fBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGToolTip(void *p) {
      return  p ? new(p) ::TGToolTip : new ::TGToolTip;
   }
   static void *newArray_TGToolTip(Long_t nElements, void *p) {
      return p ? new(p) ::TGToolTip[nElements] : new ::TGToolTip[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGToolTip(void *p) {
      delete ((::TGToolTip*)p);
   }
   static void deleteArray_TGToolTip(void *p) {
      delete [] ((::TGToolTip*)p);
   }
   static void destruct_TGToolTip(void *p) {
      typedef ::TGToolTip current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGToolTip(TBuffer &buf, void *obj) {
      ((::TGToolTip*)obj)->::TGToolTip::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGToolTip

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

   TGCompositeFrame::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGToolBar(void *p) {
      return  p ? new(p) ::TGToolBar : new ::TGToolBar;
   }
   static void *newArray_TGToolBar(Long_t nElements, void *p) {
      return p ? new(p) ::TGToolBar[nElements] : new ::TGToolBar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGToolBar(void *p) {
      delete ((::TGToolBar*)p);
   }
   static void deleteArray_TGToolBar(void *p) {
      delete [] ((::TGToolBar*)p);
   }
   static void destruct_TGToolBar(void *p) {
      typedef ::TGToolBar current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGToolBar(TBuffer &buf, void *obj) {
      ((::TGToolBar*)obj)->::TGToolBar::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGToolBar

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

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

//______________________________________________________________________________
void TGListTreeItem::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGListTreeItem.
      TClass *R__cl = ::TGListTreeItem::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(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstchild", &fFirstchild);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastchild", &fLastchild);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrevsibling", &fPrevsibling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextsibling", &fNextsibling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOpen", &fOpen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDNDState", &fDNDState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXtext", &fXtext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYtext", &fYtext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
}

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

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

   TGListTreeItem::Streamer(R__b);
}

//______________________________________________________________________________
void TGListTreeItemStd::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGListTreeItemStd.
      TClass *R__cl = ::TGListTreeItemStd::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckBox", &fCheckBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChecked", &fChecked);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnsData", &fOwnsData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fText", &fText);
      R__insp.InspectMember(fText, "fText.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTipText", &fTipText);
      R__insp.InspectMember(fTipText, "fTipText.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOpenPic", &fOpenPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClosedPic", &fClosedPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCheckedPic", &fCheckedPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUncheckedPic", &fUncheckedPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUserData", &fUserData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasColor", &fHasColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      TGListTreeItem::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGListTreeItemStd(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGListTreeItemStd : new ::TGListTreeItemStd;
   }
   static void *newArray_TGListTreeItemStd(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGListTreeItemStd[nElements] : new ::TGListTreeItemStd[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGListTreeItemStd(void *p) {
      delete ((::TGListTreeItemStd*)p);
   }
   static void deleteArray_TGListTreeItemStd(void *p) {
      delete [] ((::TGListTreeItemStd*)p);
   }
   static void destruct_TGListTreeItemStd(void *p) {
      typedef ::TGListTreeItemStd current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGListTreeItemStd(TBuffer &buf, void *obj) {
      ((::TGListTreeItemStd*)obj)->::TGListTreeItemStd::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGListTreeItemStd

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

   TGContainer::Streamer(R__b);
}

//______________________________________________________________________________
void TGListTree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGListTree.
      TClass *R__cl = ::TGListTree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLast", &fLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelected", &fSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBelowMouse", &fBelowMouse);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHspacing", &fHspacing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVspacing", &fVspacing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndent", &fIndent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMargin", &fMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrayPixel", &fGrayPixel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawGC", &fDrawGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineGC", &fLineGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlightGC", &fHighlightGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFont", &fFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefw", &fDefw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefh", &fDefh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExposeTop", &fExposeTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExposeBottom", &fExposeBottom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTipItem", &fTipItem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuf", &fBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDNDData", &fDNDData);
      R__insp.InspectMember(fDNDData, "fDNDData.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDNDTypeList", &fDNDTypeList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDropItem", &fDropItem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoTips", &fAutoTips);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoCheckBoxPic", &fAutoCheckBoxPic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisableOpen", &fDisableOpen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUserControlled", &fUserControlled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventHandled", &fEventHandled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastEventState", &fLastEventState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorMode", &fColorMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckMode", &fCheckMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorGC", &fColorGC);
      TGContainer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGListTree(void *p) {
      return  p ? new(p) ::TGListTree : new ::TGListTree;
   }
   static void *newArray_TGListTree(Long_t nElements, void *p) {
      return p ? new(p) ::TGListTree[nElements] : new ::TGListTree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGListTree(void *p) {
      delete ((::TGListTree*)p);
   }
   static void deleteArray_TGListTree(void *p) {
      delete [] ((::TGListTree*)p);
   }
   static void destruct_TGListTree(void *p) {
      typedef ::TGListTree current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGListTree(TBuffer &buf, void *obj) {
      ((::TGListTree*)obj)->::TGListTree::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGListTree

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

   TGFrame::Streamer(R__b);
}

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

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

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

   TGSplitter::Streamer(R__b);
}

//______________________________________________________________________________
void TGVSplitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGVSplitter.
      TClass *R__cl = ::TGVSplitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartX", &fStartX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameWidth", &fFrameWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameHeight", &fFrameHeight);
      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(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeft", &fLeft);
      TGSplitter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVSplitter(void *p) {
      return  p ? new(p) ::TGVSplitter : new ::TGVSplitter;
   }
   static void *newArray_TGVSplitter(Long_t nElements, void *p) {
      return p ? new(p) ::TGVSplitter[nElements] : new ::TGVSplitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVSplitter(void *p) {
      delete ((::TGVSplitter*)p);
   }
   static void deleteArray_TGVSplitter(void *p) {
      delete [] ((::TGVSplitter*)p);
   }
   static void destruct_TGVSplitter(void *p) {
      typedef ::TGVSplitter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVSplitter(TBuffer &buf, void *obj) {
      ((::TGVSplitter*)obj)->::TGVSplitter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVSplitter

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

   TGSplitter::Streamer(R__b);
}

//______________________________________________________________________________
void TGHSplitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGHSplitter.
      TClass *R__cl = ::TGHSplitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartY", &fStartY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameWidth", &fFrameWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameHeight", &fFrameHeight);
      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(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbove", &fAbove);
      TGSplitter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGHSplitter(void *p) {
      return  p ? new(p) ::TGHSplitter : new ::TGHSplitter;
   }
   static void *newArray_TGHSplitter(Long_t nElements, void *p) {
      return p ? new(p) ::TGHSplitter[nElements] : new ::TGHSplitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGHSplitter(void *p) {
      delete ((::TGHSplitter*)p);
   }
   static void deleteArray_TGHSplitter(void *p) {
      delete [] ((::TGHSplitter*)p);
   }
   static void destruct_TGHSplitter(void *p) {
      typedef ::TGHSplitter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGHSplitter(TBuffer &buf, void *obj) {
      ((::TGHSplitter*)obj)->::TGHSplitter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGHSplitter

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

   TGVSplitter::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGVFileSplitter(void *p) {
      return  p ? new(p) ::TGVFileSplitter : new ::TGVFileSplitter;
   }
   static void *newArray_TGVFileSplitter(Long_t nElements, void *p) {
      return p ? new(p) ::TGVFileSplitter[nElements] : new ::TGVFileSplitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGVFileSplitter(void *p) {
      delete ((::TGVFileSplitter*)p);
   }
   static void deleteArray_TGVFileSplitter(void *p) {
      delete [] ((::TGVFileSplitter*)p);
   }
   static void destruct_TGVFileSplitter(void *p) {
      typedef ::TGVFileSplitter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGVFileSplitter(TBuffer &buf, void *obj) {
      ((::TGVFileSplitter*)obj)->::TGVFileSplitter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGVFileSplitter

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

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

//______________________________________________________________________________
void TGText::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGText.
      TClass *R__cl = ::TGText::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilename", &fFilename);
      R__insp.InspectMember(fFilename, "fFilename.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsSaved", &fIsSaved);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentRow", &fCurrentRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowCount", &fRowCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColCount", &fColCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLongestLine", &fLongestLine);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGText(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGText : new ::TGText;
   }
   static void *newArray_TGText(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGText[nElements] : new ::TGText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGText(void *p) {
      delete ((::TGText*)p);
   }
   static void deleteArray_TGText(void *p) {
      delete [] ((::TGText*)p);
   }
   static void destruct_TGText(void *p) {
      typedef ::TGText current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGText(TBuffer &buf, void *obj) {
      ((::TGText*)obj)->::TGText::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGText

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextLine(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGTextLine : new ::TGTextLine;
   }
   static void *newArray_TGTextLine(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGTextLine[nElements] : new ::TGTextLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextLine(void *p) {
      delete ((::TGTextLine*)p);
   }
   static void deleteArray_TGTextLine(void *p) {
      delete [] ((::TGTextLine*)p);
   }
   static void destruct_TGTextLine(void *p) {
      typedef ::TGTextLine current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextLine(TBuffer &buf, void *obj) {
      ((::TGTextLine*)obj)->::TGTextLine::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextLine

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

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

//______________________________________________________________________________
void TGView::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGView.
      TClass *R__cl = ::TGView::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisible", &fVisible);
      R__insp.InspectMember(fVisible, "fVisible.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMousePos", &fMousePos);
      R__insp.InspectMember(fMousePos, "fMousePos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScrollVal", &fScrollVal);
      R__insp.InspectMember(fScrollVal, "fScrollVal.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVirtualSize", &fVirtualSize);
      R__insp.InspectMember(fVirtualSize, "fVirtualSize.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExposedRegion", &fExposedRegion);
      R__insp.InspectMember(fExposedRegion, "fExposedRegion.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScrolling", &fScrolling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipboard", &fClipboard);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXMargin", &fXMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYMargin", &fYMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHsb", &fHsb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVsb", &fVsb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWhiteGC", &fWhiteGC);
      R__insp.InspectMember(fWhiteGC, "fWhiteGC.");
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGView(void *p) {
      return  p ? new(p) ::TGView : new ::TGView;
   }
   static void *newArray_TGView(Long_t nElements, void *p) {
      return p ? new(p) ::TGView[nElements] : new ::TGView[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGView(void *p) {
      delete ((::TGView*)p);
   }
   static void deleteArray_TGView(void *p) {
      delete [] ((::TGView*)p);
   }
   static void destruct_TGView(void *p) {
      typedef ::TGView current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGView(TBuffer &buf, void *obj) {
      ((::TGView*)obj)->::TGView::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGView

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

   TGCompositeFrame::Streamer(R__b);
}

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

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

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

   TGView::Streamer(R__b);
}

//______________________________________________________________________________
void TGTextView::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTextView.
      TClass *R__cl = ::TGTextView::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(), "*fClipText", &fClipText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFont", &fFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxAscent", &fMaxAscent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDescent", &fMaxDescent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxWidth", &fMaxWidth);
      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.InspectMember(fSelbackGC, "fSelbackGC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkedFromX", &fMarkedFromX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkedFromY", &fMarkedFromY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMarked", &fIsMarked);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMarking", &fIsMarking);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsSaved", &fIsSaved);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadOnly", &fReadOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkedStart", &fMarkedStart);
      R__insp.InspectMember(fMarkedStart, "fMarkedStart.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkedEnd", &fMarkedEnd);
      R__insp.InspectMember(fMarkedEnd, "fMarkedEnd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScrollTimer", &fScrollTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDNDTypeList", &fDNDTypeList);
      TGView::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextView(void *p) {
      return  p ? new(p) ::TGTextView : new ::TGTextView;
   }
   static void *newArray_TGTextView(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextView[nElements] : new ::TGTextView[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextView(void *p) {
      delete ((::TGTextView*)p);
   }
   static void deleteArray_TGTextView(void *p) {
      delete [] ((::TGTextView*)p);
   }
   static void destruct_TGTextView(void *p) {
      typedef ::TGTextView current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextView(TBuffer &buf, void *obj) {
      ((::TGTextView*)obj)->::TGTextView::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextView

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

   TGTextView::Streamer(R__b);
}

//______________________________________________________________________________
void TGTextEdit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGTextEdit.
      TClass *R__cl = ::TGTextEdit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor0GC", &fCursor0GC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor1GC", &fCursor1GC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorState", &fCursorState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurBlink", &fCurBlink);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenu", &fMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSearch", &fSearch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrent", &fCurrent);
      R__insp.InspectMember(fCurrent, "fCurrent.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInsertMode", &fInsertMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnableMenu", &fEnableMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistory", &fHistory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnableCursorWithoutFocus", &fEnableCursorWithoutFocus);
      TGTextView::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextEdit(void *p) {
      return  p ? new(p) ::TGTextEdit : new ::TGTextEdit;
   }
   static void *newArray_TGTextEdit(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextEdit[nElements] : new ::TGTextEdit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextEdit(void *p) {
      delete ((::TGTextEdit*)p);
   }
   static void deleteArray_TGTextEdit(void *p) {
      delete [] ((::TGTextEdit*)p);
   }
   static void destruct_TGTextEdit(void *p) {
      typedef ::TGTextEdit current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextEdit(TBuffer &buf, void *obj) {
      ((::TGTextEdit*)obj)->::TGTextEdit::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextEdit

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGSearchDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGSearchDialog.
      TClass *R__cl = ::TGSearchDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF1", &fF1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF2", &fF2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF3", &fF3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF4", &fF4);
      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(), "*fL6", &fL6);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL21", &fL21);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL9", &fL9);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL10", &fL10);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSearchButton", &fSearchButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancelButton", &fCancelButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectionRadio[2]", &fDirectionRadio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCaseCheck", &fCaseCheck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fG2", &fG2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSearch", &fSearch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSearch", &fBSearch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSearch", &fLSearch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetCode", &fRetCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCombo", &fCombo);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGSearchDialog(void *p) {
      return  p ? new(p) ::TGSearchDialog : new ::TGSearchDialog;
   }
   static void *newArray_TGSearchDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGSearchDialog[nElements] : new ::TGSearchDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGSearchDialog(void *p) {
      delete ((::TGSearchDialog*)p);
   }
   static void deleteArray_TGSearchDialog(void *p) {
      delete [] ((::TGSearchDialog*)p);
   }
   static void destruct_TGSearchDialog(void *p) {
      typedef ::TGSearchDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGSearchDialog(TBuffer &buf, void *obj) {
      ((::TGSearchDialog*)obj)->::TGSearchDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGSearchDialog

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGPrintDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGPrintDialog.
      TClass *R__cl = ::TGPrintDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrinter", &fPrinter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrintCommand", &fPrintCommand);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF1", &fF1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF2", &fF2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF3", &fF3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF4", &fF4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF5", &fF5);
      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(), "*fL5", &fL5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL6", &fL6);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL7", &fL7);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL21", &fL21);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrinterIcon", &fPrinterIcon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrintButton", &fPrintButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancelButton", &fCancelButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrinterEntry", &fPrinterEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrintCommandEntry", &fPrintCommandEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBPrinter", &fBPrinter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBPrintCommand", &fBPrintCommand);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLPrinter", &fLPrinter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLPrintCommand", &fLPrintCommand);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetCode", &fRetCode);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGPrintDialog(void *p) {
      return  p ? new(p) ::TGPrintDialog : new ::TGPrintDialog;
   }
   static void *newArray_TGPrintDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGPrintDialog[nElements] : new ::TGPrintDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGPrintDialog(void *p) {
      delete ((::TGPrintDialog*)p);
   }
   static void deleteArray_TGPrintDialog(void *p) {
      delete [] ((::TGPrintDialog*)p);
   }
   static void destruct_TGPrintDialog(void *p) {
      typedef ::TGPrintDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGPrintDialog(TBuffer &buf, void *obj) {
      ((::TGPrintDialog*)obj)->::TGPrintDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGPrintDialog

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

   TGTransientFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGGotoDialog::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGGotoDialog.
      TClass *R__cl = ::TGGotoDialog::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF1", &fF1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF2", &fF2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGotoButton", &fGotoButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancelButton", &fCancelButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL1", &fL1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL5", &fL5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL6", &fL6);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fL21", &fL21);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGoTo", &fGoTo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBGoTo", &fBGoTo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLGoTo", &fLGoTo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRetCode", &fRetCode);
      TGTransientFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGGotoDialog(void *p) {
      return  p ? new(p) ::TGGotoDialog : new ::TGGotoDialog;
   }
   static void *newArray_TGGotoDialog(Long_t nElements, void *p) {
      return p ? new(p) ::TGGotoDialog[nElements] : new ::TGGotoDialog[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGGotoDialog(void *p) {
      delete ((::TGGotoDialog*)p);
   }
   static void deleteArray_TGGotoDialog(void *p) {
      delete [] ((::TGGotoDialog*)p);
   }
   static void destruct_TGGotoDialog(void *p) {
      typedef ::TGGotoDialog current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGGotoDialog(TBuffer &buf, void *obj) {
      ((::TGGotoDialog*)obj)->::TGGotoDialog::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGGotoDialog

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGSearchType(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGSearchType : new ::TGSearchType;
   }
   static void *newArray_TGSearchType(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGSearchType[nElements] : new ::TGSearchType[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGSearchType(void *p) {
      delete ((::TGSearchType*)p);
   }
   static void deleteArray_TGSearchType(void *p) {
      delete [] ((::TGSearchType*)p);
   }
   static void destruct_TGSearchType(void *p) {
      typedef ::TGSearchType current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGSearchType

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGRegion(void *p) {
      return  p ? new(p) ::TGRegion : new ::TGRegion;
   }
   static void *newArray_TGRegion(Long_t nElements, void *p) {
      return p ? new(p) ::TGRegion[nElements] : new ::TGRegion[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGRegion(void *p) {
      delete ((::TGRegion*)p);
   }
   static void deleteArray_TGRegion(void *p) {
      delete [] ((::TGRegion*)p);
   }
   static void destruct_TGRegion(void *p) {
      typedef ::TGRegion current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGRegion(TBuffer &buf, void *obj) {
      ((::TGRegion*)obj)->::TGRegion::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGRegion

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

   TGRegion::Streamer(R__b);
}

//______________________________________________________________________________
void TGRegionWithId::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGRegionWithId.
      TClass *R__cl = ::TGRegionWithId::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(), "*fTip", &fTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPopup", &fPopup);
      TGRegion::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGRegionWithId(void *p) {
      return  p ? new(p) ::TGRegionWithId : new ::TGRegionWithId;
   }
   static void *newArray_TGRegionWithId(Long_t nElements, void *p) {
      return p ? new(p) ::TGRegionWithId[nElements] : new ::TGRegionWithId[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGRegionWithId(void *p) {
      delete ((::TGRegionWithId*)p);
   }
   static void deleteArray_TGRegionWithId(void *p) {
      delete [] ((::TGRegionWithId*)p);
   }
   static void destruct_TGRegionWithId(void *p) {
      typedef ::TGRegionWithId current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGRegionWithId(TBuffer &buf, void *obj) {
      ((::TGRegionWithId*)obj)->::TGRegionWithId::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGRegionWithId

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

   TGPictureButton::Streamer(R__b);
}

//______________________________________________________________________________
void TGImageMap::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGImageMap.
      TClass *R__cl = ::TGImageMap::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListOfRegions", &fListOfRegions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNavMode", &fNavMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorMouseOver", &fCursorMouseOver);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorMouseOut", &fCursorMouseOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastVisited", &fLastVisited);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainTip", &fMainTip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrash", &fTrash);
      TGPictureButton::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGImageMap(void *p) {
      return  p ? new(p) ::TGImageMap : new ::TGImageMap;
   }
   static void *newArray_TGImageMap(Long_t nElements, void *p) {
      return p ? new(p) ::TGImageMap[nElements] : new ::TGImageMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGImageMap(void *p) {
      delete ((::TGImageMap*)p);
   }
   static void deleteArray_TGImageMap(void *p) {
      delete [] ((::TGImageMap*)p);
   }
   static void destruct_TGImageMap(void *p) {
      typedef ::TGImageMap current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGImageMap(TBuffer &buf, void *obj) {
      ((::TGImageMap*)obj)->::TGImageMap::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGImageMap

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

   TApplication::Streamer(R__b);
}

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

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

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

   TGLayoutManager::Streamer(R__b);
}

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

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

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

   TGLayoutHints::Streamer(R__b);
}

//______________________________________________________________________________
void TGXYLayoutHints::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGXYLayoutHints.
      TClass *R__cl = ::TGXYLayoutHints::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);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlag", &fFlag);
      TGLayoutHints::ShowMembers(R__insp);
}

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

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

   TGObject::Streamer(R__b);
}

//______________________________________________________________________________
void TGResourcePool::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGResourcePool.
      TClass *R__cl = ::TGResourcePool::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(), "fDocBackColor", &fDocBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDocForeColor", &fDocForeColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTipBackColor", &fTipBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTipForeColor", &fTipForeColor);
      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(), "*fFontPool", &fFontPool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultFont", &fDefaultFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuFont", &fMenuFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHiFont", &fMenuHiFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDocFixedFont", &fDocFixedFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDocPropFont", &fDocPropFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIconFont", &fIconFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusFont", &fStatusFont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicturePool", &fPicturePool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultBackPicture", &fDefaultBackPicture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultDocBackPicture", &fDefaultDocBackPicture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGCPool", &fGCPool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWhiteGC", &fWhiteGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBlackGC", &fBlackGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameGC", &fFrameGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBckgndGC", &fBckgndGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHiliteGC", &fHiliteGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShadowGC", &fShadowGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFocusGC", &fFocusGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDocGC", &fDocGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDocbgndGC", &fDocbgndGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelGC", &fSelGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelbgndGC", &fSelbgndGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTipGC", &fTipGC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckered", &fCheckered);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckeredBitmap", &fCheckeredBitmap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultCursor", &fDefaultCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrabCursor", &fGrabCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextCursor", &fTextCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaitCursor", &fWaitCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultColormap", &fDefaultColormap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipboardAtom", &fClipboardAtom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMimeTypeList", &fMimeTypeList);
      TGObject::ShowMembers(R__insp);
}

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

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

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TGFont::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGFont.
      TClass *R__cl = ::TGFont::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontStruct", &fFontStruct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontH", &fFontH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFM", (void*)&fFM);
      R__insp.InspectMember("FontMetrics_t", (void*)&fFM, "fFM.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFA", (void*)&fFA);
      R__insp.InspectMember("FontAttributes_t", (void*)&fFA, "fFA.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNamedHash", &fNamedHash);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTabWidth", &fTabWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnderlinePos", &fUnderlinePos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnderlineHeight", &fUnderlineHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypes[256]", fTypes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidths[256]", fWidths);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarHeight", &fBarHeight);
      TNamed::ShowMembers(R__insp);
      R__insp.GenericShowMembers("TRefCnt", ( ::TRefCnt *) (this ), false);
}

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

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

   TGObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGTextLayout(void *p) {
      return  p ? new(p) ::TGTextLayout : new ::TGTextLayout;
   }
   static void *newArray_TGTextLayout(Long_t nElements, void *p) {
      return p ? new(p) ::TGTextLayout[nElements] : new ::TGTextLayout[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGTextLayout(void *p) {
      delete ((::TGTextLayout*)p);
   }
   static void deleteArray_TGTextLayout(void *p) {
      delete [] ((::TGTextLayout*)p);
   }
   static void destruct_TGTextLayout(void *p) {
      typedef ::TGTextLayout current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGTextLayout(TBuffer &buf, void *obj) {
      ((::TGTextLayout*)obj)->::TGTextLayout::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGTextLayout

namespace ROOT {
   // Wrappers around operator new
   static void *new_FontMetrics_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::FontMetrics_t : new ::FontMetrics_t;
   }
   static void *newArray_FontMetrics_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::FontMetrics_t[nElements] : new ::FontMetrics_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_FontMetrics_t(void *p) {
      delete ((::FontMetrics_t*)p);
   }
   static void deleteArray_FontMetrics_t(void *p) {
      delete [] ((::FontMetrics_t*)p);
   }
   static void destruct_FontMetrics_t(void *p) {
      typedef ::FontMetrics_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::FontMetrics_t

namespace ROOT {
   // Wrappers around operator new
   static void *new_FontAttributes_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::FontAttributes_t : new ::FontAttributes_t;
   }
   static void *newArray_FontAttributes_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::FontAttributes_t[nElements] : new ::FontAttributes_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_FontAttributes_t(void *p) {
      delete ((::FontAttributes_t*)p);
   }
   static void deleteArray_FontAttributes_t(void *p) {
      delete [] ((::FontAttributes_t*)p);
   }
   static void destruct_FontAttributes_t(void *p) {
      typedef ::FontAttributes_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::FontAttributes_t

namespace ROOT {
   // Wrappers around operator new
   static void *new_ToolBarData_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ToolBarData_t : new ::ToolBarData_t;
   }
   static void *newArray_ToolBarData_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ToolBarData_t[nElements] : new ::ToolBarData_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_ToolBarData_t(void *p) {
      delete ((::ToolBarData_t*)p);
   }
   static void deleteArray_ToolBarData_t(void *p) {
      delete [] ((::ToolBarData_t*)p);
   }
   static void destruct_ToolBarData_t(void *p) {
      typedef ::ToolBarData_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ToolBarData_t

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

extern "C" void G__set_cpp_environmentG__Gui2() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TGObject.h");
  G__add_compiledheader("TGScrollBar.h");
  G__add_compiledheader("TGCanvas.h");
  G__add_compiledheader("TGListBox.h");
  G__add_compiledheader("TGComboBox.h");
  G__add_compiledheader("TGTab.h");
  G__add_compiledheader("TGSlider.h");
  G__add_compiledheader("TGPicture.h");
  G__add_compiledheader("TGListView.h");
  G__add_compiledheader("TGMimeTypes.h");
  G__add_compiledheader("TGFSContainer.h");
  G__add_compiledheader("TGFileDialog.h");
  G__add_compiledheader("TGStatusBar.h");
  G__add_compiledheader("TGToolTip.h");
  G__add_compiledheader("TGToolBar.h");
  G__add_compiledheader("TGListTree.h");
  G__add_compiledheader("TGText.h");
  G__add_compiledheader("TGView.h");
  G__add_compiledheader("TGTextView.h");
  G__add_compiledheader("TGTextEdit.h");
  G__add_compiledheader("TGTextEditDialogs.h");
  G__add_compiledheader("TGDoubleSlider.h");
  G__add_compiledheader("TGSplitter.h");
  G__add_compiledheader("TGFSComboBox.h");
  G__add_compiledheader("TGImageMap.h");
  G__add_compiledheader("TGApplication.h");
  G__add_compiledheader("TGXYLayout.h");
  G__add_compiledheader("TGResourcePool.h");
  G__add_compiledheader("TGFont.h");
  G__add_compiledheader("TGTripleSlider.h");
  G__cpp_reset_tagtableG__Gui2();
}
#include <new>
extern "C" int G__cpp_dllrevG__Gui2() { return(30051515); }

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

/* TGResourcePool */
static int G__G__Gui2_133_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGResourcePool* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGResourcePool((TGClient*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGResourcePool((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__Gui2LN_TGResourcePool));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic copy constructor
static int G__G__Gui2_133_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGResourcePool* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGResourcePool(*(TGResourcePool*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool));
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TGFontPool */
static int G__G__Gui2_138_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFontPool* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGFontPool((TGClient*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGFontPool((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__Gui2LN_TGFontPool));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_138_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGFontPool*) 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) ((TGFontPool*) G__getstructoffset())->GetFont((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Gui2_138_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGFontPool*) G__getstructoffset())->GetFont((const char*) 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])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Gui2_138_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGFontPool*) G__getstructoffset())->GetAttributeInfo((FontAttributes_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui2_138_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGFontPool*) G__getstructoffset())->GetFontFamilies());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Gui2_138_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGFontPool*) G__getstructoffset())->NameOfFont((TGFont*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Gui2_139_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const FontAttributes_t* pobj;
         const FontAttributes_t xobj = ((const TGFont*) G__getstructoffset())->GetFontAttributes();
         pobj = new FontAttributes_t(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Gui2_139_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGFont*) G__getstructoffset())->UnderlineChars(
(Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_139_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGFont*) G__getstructoffset())->ComputeTextLayout(
(const char*) 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]), (UInt_t*) G__int(libp->para[5])
, (UInt_t*) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_139_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFont*) G__getstructoffset())->MeasureChars((const char*) 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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_139_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGFont*) G__getstructoffset())->DrawCharsExp((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_139_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGFont*) G__getstructoffset())->DrawChars((Drawable_t) G__int(libp->para[0]), (GContext_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TGMimeTypes */
static int G__G__Gui2_140_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGMimeTypes* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGMimeTypes((TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGMimeTypes((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__Gui2LN_TGMimeTypes));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Gui2_140_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGMimeTypes*) G__getstructoffset())->AddType((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

// automatic copy constructor
static int G__G__Gui2_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   FontMetrics_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new FontMetrics_t(*(FontMetrics_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

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

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


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

static int G__G__Gui2_172_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGTextLayout*) G__getstructoffset())->DrawText((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])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_172_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGTextLayout*) G__getstructoffset())->UnderlineChar((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])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui2_172_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextLayout*) G__getstructoffset())->CharBbox((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])
, (Int_t*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Gui2_172_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextLayout*) G__getstructoffset())->IntersectText((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


/* TGVFileSplitter */
static int G__G__Gui2_202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVFileSplitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVFileSplitter(
(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) TGVFileSplitter(
(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 TGVFileSplitter(
(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) TGVFileSplitter(
(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 TGVFileSplitter(
(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) TGVFileSplitter(
(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 TGVFileSplitter((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVFileSplitter((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 TGVFileSplitter((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVFileSplitter((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVFileSplitter[n];
       } else {
         p = new((void*) gvp) TGVFileSplitter[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVFileSplitter;
       } else {
         p = new((void*) gvp) TGVFileSplitter;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGToolTip */
static int G__G__Gui2_225_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGToolTip* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGToolTip(
(TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGToolTip(
(TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGToolTip(
(TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGToolTip(
(TGWindow*) G__int(libp->para[0]), (TGFrame*) 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 TGToolTip((TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGToolTip((TGWindow*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGToolTip((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGToolTip((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGToolTip[n];
       } else {
         p = new((void*) gvp) TGToolTip[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGToolTip;
       } else {
         p = new((void*) gvp) TGToolTip;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_225_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGToolTip* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGToolTip(
(TGWindow*) G__int(libp->para[0]), (TBox*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGToolTip(
(TGWindow*) G__int(libp->para[0]), (TBox*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_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__Gui2LN_TGToolTip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_225_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGToolTip* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGToolTip(
(TBox*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGToolTip(
(TBox*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_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__Gui2LN_TGToolTip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_225_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGToolTip* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGToolTip(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGToolTip(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Long_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__Gui2LN_TGToolTip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_225_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolTip*) G__getstructoffset())->Show((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__Gui2_225_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolTip*) G__getstructoffset())->Hide();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Gui2_225_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolTip*) G__getstructoffset())->SetPosition((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__Gui2_225_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolTip*) G__getstructoffset())->SetDelay((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


/* TGScrollBarElement */
static int G__G__Gui2_234_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGScrollBarElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGScrollBarElement(
(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) TGScrollBarElement(
(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 TGScrollBarElement(
(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) TGScrollBarElement(
(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 TGScrollBarElement(
(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) TGScrollBarElement(
(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;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGScrollBarElement(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGScrollBarElement(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) 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 TGScrollBarElement((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGScrollBarElement((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGScrollBarElement((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGScrollBarElement((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGScrollBarElement[n];
       } else {
         p = new((void*) gvp) TGScrollBarElement[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGScrollBarElement;
       } else {
         p = new((void*) gvp) TGScrollBarElement;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TGScrollBar */
static int G__G__Gui2_235_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGScrollBar::GetBckgndPixmap());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Gui2_235_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGScrollBar*) G__getstructoffset())->SetRange((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__Gui2_235_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGScrollBar*) G__getstructoffset())->SetPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Gui2_235_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGScrollBar*) G__getstructoffset())->GetSmallIncrement());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


/* TGHScrollBar */
static int G__G__Gui2_236_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHScrollBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHScrollBar(
(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) TGHScrollBar(
(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 TGHScrollBar(
(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) TGHScrollBar(
(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 TGHScrollBar(
(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) TGHScrollBar(
(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 TGHScrollBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHScrollBar((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 TGHScrollBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHScrollBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHScrollBar[n];
       } else {
         p = new((void*) gvp) TGHScrollBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHScrollBar;
       } else {
         p = new((void*) gvp) TGHScrollBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TGVScrollBar */
static int G__G__Gui2_237_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVScrollBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVScrollBar(
(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) TGVScrollBar(
(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 TGVScrollBar(
(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) TGVScrollBar(
(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 TGVScrollBar(
(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) TGVScrollBar(
(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 TGVScrollBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVScrollBar((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 TGVScrollBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVScrollBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVScrollBar[n];
       } else {
         p = new((void*) gvp) TGVScrollBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVScrollBar;
       } else {
         p = new((void*) gvp) TGVScrollBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TGViewPort */
static int G__G__Gui2_238_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGViewPort* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGViewPort(
(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) TGViewPort(
(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 TGViewPort(
(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) TGViewPort(
(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 TGViewPort(
(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) TGViewPort(
(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 TGViewPort((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGViewPort((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 TGViewPort((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGViewPort((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGViewPort[n];
       } else {
         p = new((void*) gvp) TGViewPort[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGViewPort;
       } else {
         p = new((void*) gvp) TGViewPort;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Gui2_238_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGViewPort*) G__getstructoffset())->SetPos((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__Gui2_238_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGViewPort*) G__getstructoffset())->GetHPos());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


/* TGCanvas */
static int G__G__Gui2_239_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGCanvas* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGCanvas(
(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) TGCanvas(
(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 TGCanvas(
(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) TGCanvas(
(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 TGCanvas(
(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) TGCanvas(
(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 TGCanvas((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGCanvas((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 TGCanvas((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGCanvas((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGCanvas[n];
       } else {
         p = new((void*) gvp) TGCanvas[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGCanvas;
       } else {
         p = new((void*) gvp) TGCanvas;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Gui2_239_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGCanvas*) G__getstructoffset())->AddFrame((TGFrame*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGCanvas*) G__getstructoffset())->AddFrame((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Gui2_239_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCanvas*) G__getstructoffset())->SetVsbPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCanvas*) G__getstructoffset())->SetScrolling((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGCanvas*) G__getstructoffset())->GetScrolling());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGCanvas::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCanvas::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGCanvas::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGCanvas::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGCanvas*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCanvas::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCanvas::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGCanvas::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_239_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGCanvas::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGCanvas G__TTGCanvas;
static int G__G__Gui2_239_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[] (TGCanvas*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGCanvas*) (soff+(sizeof(TGCanvas)*i)))->~G__TTGCanvas();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGCanvas*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGCanvas*) (soff))->~G__TTGCanvas();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListView */
static int G__G__Gui2_243_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListView(
(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) TGListView(
(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 TGListView(
(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) TGListView(
(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 TGListView(
(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) TGListView(
(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__Gui2LN_TGListView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->ResizeColumns();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->LayoutHeader((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->ScrollHeader((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->AdjustHeaders();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SetHeaders((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SetHeader((const char*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SetDefaultHeaders();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SetViewMode((EListViewMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListView*) G__getstructoffset())->GetHeaderButtons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TGListView*) G__getstructoffset())->GetNumColumns());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListView*) G__getstructoffset())->GetViewMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGListView*) G__getstructoffset())->GetHeader((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SetIncrements((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__Gui2_243_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SetDefaultColumnWidth((TGVFileSplitter*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGListView*) G__getstructoffset())->GetMaxItemSize();
         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__Gui2_243_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->SelectionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->Clicked((TGLVEntry*) 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__Gui2_243_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->Clicked((TGLVEntry*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->DoubleClicked((TGLVEntry*) 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__Gui2_243_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->DoubleClicked((TGLVEntry*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListView::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListView::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListView::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListView::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListView::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListView::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListView::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_243_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListView::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListView G__TTGListView;
static int G__G__Gui2_243_0_42(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[] (TGListView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListView*) (soff+(sizeof(TGListView)*i)))->~G__TTGListView();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListView*) (soff))->~G__TTGListView();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGContainer */
static int G__G__Gui2_244_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGContainer(
(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) TGContainer(
(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 TGContainer(
(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) TGContainer(
(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 TGContainer(
(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) TGContainer(
(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 TGContainer((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGContainer((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 TGContainer((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGContainer((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGContainer[n];
       } else {
         p = new((void*) gvp) TGContainer[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGContainer;
       } else {
         p = new((void*) gvp) TGContainer;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGContainer(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGContainer(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGContainer((TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGContainer((TGCanvas*) 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 TGContainer((TGCanvas*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGContainer((TGCanvas*) 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__Gui2LN_TGContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->DrawRegion((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__Gui2_244_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->ClearViewPort();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->Associate((TGWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->AdjustPosition();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetPagePosition(*(TGPosition*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetPagePosition((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__Gui2_244_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetPageDimension(*(TGDimension*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetPageDimension((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__Gui2_244_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->RemoveItem((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGContainer*) G__getstructoffset())->GetCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGContainer*) G__getstructoffset())->GetMessageWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPosition* pobj;
         const TGPosition xobj = ((const TGContainer*) G__getstructoffset())->GetPagePosition();
         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__Gui2_244_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGContainer*) G__getstructoffset())->GetPageDimension();
         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__Gui2_244_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGContainer*) G__getstructoffset())->NumSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGContainer*) G__getstructoffset())->NumItems());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGContainer*) G__getstructoffset())->FindFrame((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGContainer*) G__getstructoffset())->FindFrame((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGContainer*) G__getstructoffset())->FindFrameByName((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGContainer*) G__getstructoffset())->GetHScrollbar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGContainer*) G__getstructoffset())->GetVScrollbar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetHsbPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetVsbPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->LineUp((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->LineUp();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->LineDown((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->LineDown();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->LineLeft((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->LineLeft();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->LineRight((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->LineRight();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->PageUp((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->PageUp();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->PageDown((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->PageDown();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->Home((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->Home();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->End((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->End();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGContainer*) G__getstructoffset())->Search((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGContainer*) G__getstructoffset())->Search();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 89, (long) ((TGContainer*) G__getstructoffset())->FindItem(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 89, (long) ((TGContainer*) G__getstructoffset())->FindItem(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 89, (long) ((TGContainer*) G__getstructoffset())->FindItem(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 89, (long) ((TGContainer*) G__getstructoffset())->FindItem(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGContainer*) G__getstructoffset())->GetNextSelected((void**) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGContainer*) G__getstructoffset())->GetLastActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGContainer*) G__getstructoffset())->GetObjPicture((TGFrame*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SetDragPixmap((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SelectAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->UnSelectAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->InvertSelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->ReturnPressed((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->SpacePressed((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->KeyPressed((TGFrame*) 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__Gui2_244_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->OnMouseOver((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->CurrentChanged((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__Gui2_244_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->CurrentChanged((TGFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->Clicked((TGFrame*) 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__Gui2_244_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->DoubleClicked((TGFrame*) 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__Gui2_244_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->DoubleClicked((TGFrame*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->Clicked((TGFrame*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGContainer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGContainer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGContainer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGContainer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGContainer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGContainer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGContainer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGContainer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_244_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGContainer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGContainer G__TTGContainer;
static int G__G__Gui2_244_0_81(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[] (TGContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGContainer*) (soff+(sizeof(TGContainer)*i)))->~G__TTGContainer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGContainer*) (soff))->~G__TTGContainer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListBox */
static int G__G__Gui2_246_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListBox(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGListBox(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGListBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGListBox(
(TGWindow*) 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 TGListBox((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGListBox((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 TGListBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGListBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGListBox[n];
       } else {
         p = new((void*) gvp) TGListBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGListBox;
       } else {
         p = new((void*) gvp) TGListBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGListBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->AddEntry((TGString*) 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__Gui2_246_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->AddEntry((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__Gui2_246_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->AddEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->AddEntrySort((TGString*) 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__Gui2_246_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->AddEntrySort((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__Gui2_246_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->AddEntrySort((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->InsertEntry((TGString*) 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__Gui2_246_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->InsertEntry((const char*) 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__Gui2_246_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->InsertEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) 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__Gui2_246_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListBox*) G__getstructoffset())->NewEntry((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListBox*) G__getstructoffset())->NewEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListBox*) G__getstructoffset())->RemoveEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListBox*) G__getstructoffset())->RemoveEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->RemoveEntries((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__Gui2_246_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListBox*) G__getstructoffset())->SetTopEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListBox*) G__getstructoffset())->SetTopEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListBox*) G__getstructoffset())->SetMultipleSelections((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListBox*) G__getstructoffset())->SetMultipleSelections();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListBox*) G__getstructoffset())->GetMultipleSelections());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListBox*) G__getstructoffset())->GetNumberOfEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->GetEntry((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->FindEntry((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->GetContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->GetViewPort());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->GetScrollBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->GetVScrollbar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListBox*) G__getstructoffset())->SortByName((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListBox*) G__getstructoffset())->SortByName();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->IntegralHeight((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGListBox*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGListBox*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListBox*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGListBox*) G__getstructoffset())->GetSelection((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListBox*) G__getstructoffset())->GetSelectedEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->GetSelectedEntries((TList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGListBox*) G__getstructoffset())->GetItemVsize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->Selected((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__Gui2_246_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->Selected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->Selected((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->DoubleClicked((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__Gui2_246_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->DoubleClicked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->DoubleClicked((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->SelectionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_246_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListBox G__TTGListBox;
static int G__G__Gui2_246_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[] (TGListBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListBox*) (soff+(sizeof(TGListBox)*i)))->~G__TTGListBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListBox*) (soff))->~G__TTGListBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLBEntry */
static int G__G__Gui2_247_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLBEntry(
(TGWindow*) 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 TGLBEntry((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLBEntry((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 TGLBEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLBEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLBEntry[n];
       } else {
         p = new((void*) gvp) TGLBEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLBEntry;
       } else {
         p = new((void*) gvp) TGLBEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBEntry*) G__getstructoffset())->Toggle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBEntry*) G__getstructoffset())->Update((TGLBEntry*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLBEntry*) G__getstructoffset())->EntryId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLBEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLBEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLBEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_247_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLBEntry G__TTGLBEntry;
static int G__G__Gui2_247_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[] (TGLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLBEntry*) (soff+(sizeof(TGLBEntry)*i)))->~G__TTGLBEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLBEntry*) (soff))->~G__TTGLBEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextLBEntry */
static int G__G__Gui2_248_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGTextLBEntry::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGTextLBEntry::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextLBEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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) TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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 TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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) TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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 TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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) TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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 TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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 TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTextLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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 TGTextLBEntry((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextLBEntry((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextLBEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextLBEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextLBEntry[n];
       } else {
         p = new((void*) gvp) TGTextLBEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextLBEntry;
       } else {
         p = new((void*) gvp) TGTextLBEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextLBEntry*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLBEntry*) G__getstructoffset())->SetText((TGString*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLBEntry*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTextLBEntry*) G__getstructoffset())->GetNormGC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGTextLBEntry*) G__getstructoffset())->GetFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextLBEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextLBEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextLBEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextLBEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLBEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextLBEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextLBEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextLBEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_248_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextLBEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextLBEntry G__TTGTextLBEntry;
static int G__G__Gui2_248_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[] (TGTextLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextLBEntry*) (soff+(sizeof(TGTextLBEntry)*i)))->~G__TTGTextLBEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextLBEntry*) (soff))->~G__TTGTextLBEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLineLBEntry */
static int G__G__Gui2_249_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLineLBEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Style_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) TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Style_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 TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Style_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Style_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 TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Style_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Style_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) 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 TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLineLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) 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 TGLineLBEntry((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLineLBEntry((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 TGLineLBEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLineLBEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLineLBEntry[n];
       } else {
         p = new((void*) gvp) TGLineLBEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLineLBEntry;
       } else {
         p = new((void*) gvp) TGLineLBEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLineLBEntry*) G__getstructoffset())->GetLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLineLBEntry*) G__getstructoffset())->SetLineWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLineLBEntry*) G__getstructoffset())->GetLineStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLineLBEntry*) G__getstructoffset())->SetLineStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLineLBEntry*) G__getstructoffset())->GetLineGC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLineLBEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineLBEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLineLBEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLineLBEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLineLBEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineLBEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLineLBEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineLBEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLineLBEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLineLBEntry G__TTGLineLBEntry;
static int G__G__Gui2_249_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[] (TGLineLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLineLBEntry*) (soff+(sizeof(TGLineLBEntry)*i)))->~G__TTGLineLBEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLineLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLineLBEntry*) (soff))->~G__TTGLineLBEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGIconLBEntry */
static int G__G__Gui2_250_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGIconLBEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Style_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (Pixel_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Style_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (Pixel_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Style_t) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Style_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 TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Style_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Style_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) 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 TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGIconLBEntry(
(TGWindow*) G__int(libp->para[0]), (Int_t) 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 TGIconLBEntry((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGIconLBEntry((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 TGIconLBEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGIconLBEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGIconLBEntry[n];
       } else {
         p = new((void*) gvp) TGIconLBEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGIconLBEntry;
       } else {
         p = new((void*) gvp) TGIconLBEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGIconLBEntry*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGIconLBEntry*) G__getstructoffset())->SetPicture((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGIconLBEntry*) G__getstructoffset())->SetPicture();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGIconLBEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIconLBEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGIconLBEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGIconLBEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGIconLBEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIconLBEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGIconLBEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGIconLBEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGIconLBEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGIconLBEntry G__TTGIconLBEntry;
static int G__G__Gui2_250_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGIconLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGIconLBEntry*) (soff+(sizeof(TGIconLBEntry)*i)))->~G__TTGIconLBEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGIconLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGIconLBEntry*) (soff))->~G__TTGIconLBEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLBContainer */
static int G__G__Gui2_251_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLBContainer(
(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) TGLBContainer(
(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 TGLBContainer(
(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) TGLBContainer(
(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 TGLBContainer(
(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) TGLBContainer(
(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 TGLBContainer((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLBContainer((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 TGLBContainer((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLBContainer((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLBContainer[n];
       } else {
         p = new((void*) gvp) TGLBContainer[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLBContainer;
       } else {
         p = new((void*) gvp) TGLBContainer;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->AddEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->AddEntrySort((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->InsertEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) 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__Gui2_251_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->RemoveEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->RemoveEntries((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__Gui2_251_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->SetListBox((TGListBox*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLBContainer*) G__getstructoffset())->GetListBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLBContainer*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLBContainer*) G__getstructoffset())->GetSelection((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLBContainer*) G__getstructoffset())->GetPos((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLBContainer*) G__getstructoffset())->GetSelectedEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->GetSelectedEntries((TList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLBContainer*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLBContainer*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->SetMultipleSelections((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLBContainer*) G__getstructoffset())->GetMultipleSelections());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLBContainer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBContainer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLBContainer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLBContainer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBContainer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBContainer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBContainer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBContainer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_251_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBContainer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLBContainer G__TTGLBContainer;
static int G__G__Gui2_251_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[] (TGLBContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLBContainer*) (soff+(sizeof(TGLBContainer)*i)))->~G__TTGLBContainer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLBContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLBContainer*) (soff))->~G__TTGLBContainer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGComboBoxPopup */
static int G__G__Gui2_253_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGComboBoxPopup* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGComboBoxPopup(
(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) TGComboBoxPopup(
(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 TGComboBoxPopup(
(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) TGComboBoxPopup(
(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 TGComboBoxPopup(
(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) TGComboBoxPopup(
(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 TGComboBoxPopup((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGComboBoxPopup((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 TGComboBoxPopup((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGComboBoxPopup((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGComboBoxPopup[n];
       } else {
         p = new((void*) gvp) TGComboBoxPopup[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGComboBoxPopup;
       } else {
         p = new((void*) gvp) TGComboBoxPopup;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBoxPopup*) G__getstructoffset())->SetListBox((TGListBox*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBoxPopup*) G__getstructoffset())->PlacePopup((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__Gui2_253_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBoxPopup*) G__getstructoffset())->EndPopup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGComboBoxPopup::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGComboBoxPopup::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGComboBoxPopup::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGComboBoxPopup::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBoxPopup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGComboBoxPopup::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGComboBoxPopup::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGComboBoxPopup::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_253_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGComboBoxPopup::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGComboBoxPopup G__TTGComboBoxPopup;
static int G__G__Gui2_253_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[] (TGComboBoxPopup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGComboBoxPopup*) (soff+(sizeof(TGComboBoxPopup)*i)))->~G__TTGComboBoxPopup();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGComboBoxPopup*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGComboBoxPopup*) (soff))->~G__TTGComboBoxPopup();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGComboBox */
static int G__G__Gui2_254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGComboBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGComboBox(
(TGWindow*) 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 TGComboBox((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGComboBox((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 TGComboBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGComboBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGComboBox[n];
       } else {
         p = new((void*) gvp) TGComboBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGComboBox;
       } else {
         p = new((void*) gvp) TGComboBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGComboBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGComboBox(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_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) TGComboBox(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_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 TGComboBox(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGComboBox(
(TGWindow*) G__int(libp->para[0]), (const char*) 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 TGComboBox(
(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) TGComboBox(
(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 TGComboBox((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGComboBox((TGWindow*) G__int(libp->para[0]), (const char*) 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__Gui2LN_TGComboBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->AddEntry((TGString*) 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__Gui2_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->AddEntry((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__Gui2_254_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->AddEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->InsertEntry((TGString*) 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__Gui2_254_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->InsertEntry((const char*) 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__Gui2_254_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->InsertEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) 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__Gui2_254_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGComboBox*) G__getstructoffset())->NewEntry((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGComboBox*) G__getstructoffset())->NewEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGComboBox*) G__getstructoffset())->RemoveEntry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGComboBox*) G__getstructoffset())->RemoveEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGComboBox*) G__getstructoffset())->IsTextInputEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->EnableTextInput((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->RemoveEntries((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__Gui2_254_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGComboBox*) G__getstructoffset())->GetNumberOfEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGComboBox*) G__getstructoffset())->GetListBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGComboBox*) G__getstructoffset())->GetTextEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGComboBox*) G__getstructoffset())->FindEntry((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGComboBox*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGComboBox*) G__getstructoffset())->Select((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGComboBox*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGComboBox*) G__getstructoffset())->GetSelectedEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->SetTopEntry((TGLBEntry*) G__int(libp->para[0]), (TGLayoutHints*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGComboBox*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGComboBox*) G__getstructoffset())->SetEnabled();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGComboBox*) G__getstructoffset())->SortByName((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGComboBox*) G__getstructoffset())->SortByName();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->Selected((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__Gui2_254_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->Selected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->Selected((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->ReturnPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGComboBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGComboBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGComboBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGComboBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGComboBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGComboBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGComboBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGComboBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_254_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGComboBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGComboBox G__TTGComboBox;
static int G__G__Gui2_254_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[] (TGComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGComboBox*) (soff+(sizeof(TGComboBox)*i)))->~G__TTGComboBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGComboBox*) (soff))->~G__TTGComboBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLineStyleComboBox */
static int G__G__Gui2_255_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLineStyleComboBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLineStyleComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGLineStyleComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGLineStyleComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLineStyleComboBox(
(TGWindow*) 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 TGLineStyleComboBox((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLineStyleComboBox((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 TGLineStyleComboBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLineStyleComboBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLineStyleComboBox[n];
       } else {
         p = new((void*) gvp) TGLineStyleComboBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLineStyleComboBox;
       } else {
         p = new((void*) gvp) TGLineStyleComboBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLineStyleComboBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineStyleComboBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLineStyleComboBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLineStyleComboBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLineStyleComboBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineStyleComboBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLineStyleComboBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineStyleComboBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_255_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLineStyleComboBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLineStyleComboBox G__TTGLineStyleComboBox;
static int G__G__Gui2_255_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLineStyleComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLineStyleComboBox*) (soff+(sizeof(TGLineStyleComboBox)*i)))->~G__TTGLineStyleComboBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLineStyleComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLineStyleComboBox*) (soff))->~G__TTGLineStyleComboBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLineWidthComboBox */
static int G__G__Gui2_256_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLineWidthComboBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLineWidthComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLineWidthComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Pixel_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLineWidthComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGLineWidthComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGLineWidthComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLineWidthComboBox(
(TGWindow*) 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 TGLineWidthComboBox((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLineWidthComboBox((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 TGLineWidthComboBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLineWidthComboBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLineWidthComboBox[n];
       } else {
         p = new((void*) gvp) TGLineWidthComboBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLineWidthComboBox;
       } else {
         p = new((void*) gvp) TGLineWidthComboBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLineWidthComboBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineWidthComboBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLineWidthComboBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLineWidthComboBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLineWidthComboBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineWidthComboBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLineWidthComboBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLineWidthComboBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_256_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLineWidthComboBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLineWidthComboBox G__TTGLineWidthComboBox;
static int G__G__Gui2_256_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[] (TGLineWidthComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLineWidthComboBox*) (soff+(sizeof(TGLineWidthComboBox)*i)))->~G__TTGLineWidthComboBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLineWidthComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLineWidthComboBox*) (soff))->~G__TTGLineWidthComboBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFontTypeComboBox */
static int G__G__Gui2_257_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFontTypeComboBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFontTypeComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGFontTypeComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGFontTypeComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFontTypeComboBox(
(TGWindow*) 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 TGFontTypeComboBox((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFontTypeComboBox((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 TGFontTypeComboBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFontTypeComboBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFontTypeComboBox[n];
       } else {
         p = new((void*) gvp) TGFontTypeComboBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFontTypeComboBox;
       } else {
         p = new((void*) gvp) TGFontTypeComboBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFontTypeComboBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFontTypeComboBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFontTypeComboBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFontTypeComboBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFontTypeComboBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFontTypeComboBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFontTypeComboBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFontTypeComboBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_257_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFontTypeComboBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFontTypeComboBox G__TTGFontTypeComboBox;
static int G__G__Gui2_257_0_14(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[] (TGFontTypeComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFontTypeComboBox*) (soff+(sizeof(TGFontTypeComboBox)*i)))->~G__TTGFontTypeComboBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFontTypeComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFontTypeComboBox*) (soff))->~G__TTGFontTypeComboBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTabElement */
static int G__G__Gui2_258_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTabElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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]), (Pixel_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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]), (Pixel_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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) TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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 TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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) TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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 TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (GContext_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_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 TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) 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 TGTabElement(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTabElement(
(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 TGTabElement((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTabElement((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTabElement((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTabElement((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTabElement[n];
       } else {
         p = new((void*) gvp) TGTabElement[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTabElement;
       } else {
         p = new((void*) gvp) TGTabElement;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTabElement*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGTabElement*) G__getstructoffset())->GetString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTabElement*) G__getstructoffset())->SetText((TGString*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTabElement*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTabElement*) G__getstructoffset())->SetEnabled();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTabElement*) G__getstructoffset())->IsEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTabElement*) G__getstructoffset())->ShowClose((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTabElement*) G__getstructoffset())->ShowClose();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTabElement*) G__getstructoffset())->IsCloseShown());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTabElement*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTabElement*) G__getstructoffset())->SetActive();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTabElement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTabElement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTabElement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTabElement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTabElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTabElement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTabElement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTabElement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_258_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTabElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTabElement G__TTGTabElement;
static int G__G__Gui2_258_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[] (TGTabElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTabElement*) (soff+(sizeof(TGTabElement)*i)))->~G__TTGTabElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTabElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTabElement*) (soff))->~G__TTGTabElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTab */
static int G__G__Gui2_259_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGTab::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGTab::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTab* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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]), (UInt_t) G__int(libp->para[5])
, (Pixel_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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]), (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 TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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]), (UInt_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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) TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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 TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTab(
(TGWindow*) G__int(libp->para[0]), (UInt_t) 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 TGTab(
(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) TGTab(
(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 TGTab((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTab((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 TGTab((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTab((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTab[n];
       } else {
         p = new((void*) gvp) TGTab[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTab;
       } else {
         p = new((void*) gvp) TGTab;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTab));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTab*) G__getstructoffset())->AddTab((TGString*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGTab*) G__getstructoffset())->AddTab((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTab*) G__getstructoffset())->AddTab((const char*) G__int(libp->para[0]), (TGCompositeFrame*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTab*) G__getstructoffset())->AddTab((TGString*) G__int(libp->para[0]), (TGCompositeFrame*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTab*) G__getstructoffset())->NewTab((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTab*) G__getstructoffset())->NewTab();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTab*) G__getstructoffset())->RemoveTab((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTab*) G__getstructoffset())->RemoveTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTab*) G__getstructoffset())->RemoveTab();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGTab*) G__getstructoffset())->SetTab((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGTab*) G__getstructoffset())->SetTab((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGTab*) G__getstructoffset())->SetTab((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGTab*) G__getstructoffset())->SetTab((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTab*) G__getstructoffset())->GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetTabContainer((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetTabContainer((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetTabTab((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetTabTab((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetCurrentContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTab*) G__getstructoffset())->GetCurrentTab());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGTab*) G__getstructoffset())->GetTabHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTab*) G__getstructoffset())->GetNumberOfTabs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGTab*) G__getstructoffset())->SetEnabled((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGTab*) G__getstructoffset())->SetEnabled((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTab*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTab*) G__getstructoffset())->SetText();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTab*) G__getstructoffset())->IsEnabled((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTab*) G__getstructoffset())->CloseTab((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTab*) G__getstructoffset())->Removed((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTab*) G__getstructoffset())->Selected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTab::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTab::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTab::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTab::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTab*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTab::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTab::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTab::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_259_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTab::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTab G__TTGTab;
static int G__G__Gui2_259_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[] (TGTab*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTab*) (soff+(sizeof(TGTab)*i)))->~G__TTGTab();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTab*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTab*) (soff))->~G__TTGTab();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTabLayout */
static int G__G__Gui2_260_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTabLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGTabLayout((TGTab*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGTabLayout((TGTab*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTabLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTabLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTabLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTabLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTabLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTabLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTabLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTabLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_260_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTabLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTabLayout G__TTGTabLayout;
static int G__G__Gui2_260_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[] (TGTabLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTabLayout*) (soff+(sizeof(TGTabLayout)*i)))->~G__TTGTabLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTabLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTabLayout*) (soff))->~G__TTGTabLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSlider */
static int G__G__Gui2_263_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGSlider*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGSlider*) G__getstructoffset())->SetEnabled();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->SetScale((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->SetRange((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__Gui2_263_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->SetPosition((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGSlider*) G__getstructoffset())->GetPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGSlider*) G__getstructoffset())->GetMinPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGSlider*) G__getstructoffset())->GetMaxPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGSlider*) G__getstructoffset())->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->ChangeSliderPic((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->PositionChanged((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->Pressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->Released();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_263_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSlider G__TTGSlider;
static int G__G__Gui2_263_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[] (TGSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSlider*) (soff+(sizeof(TGSlider)*i)))->~G__TTGSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSlider*) (soff))->~G__TTGSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVSlider */
static int G__G__Gui2_264_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVSlider* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGVSlider(
(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])
, (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 TGVSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGVSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVSlider(
(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) TGVSlider(
(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 TGVSlider(
(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) TGVSlider(
(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 TGVSlider((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVSlider((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 TGVSlider((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVSlider((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVSlider[n];
       } else {
         p = new((void*) gvp) TGVSlider[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVSlider;
       } else {
         p = new((void*) gvp) TGVSlider;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_264_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVSlider G__TTGVSlider;
static int G__G__Gui2_264_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGVSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVSlider*) (soff+(sizeof(TGVSlider)*i)))->~G__TTGVSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVSlider*) (soff))->~G__TTGVSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHSlider */
static int G__G__Gui2_265_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHSlider* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGHSlider(
(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])
, (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 TGHSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGHSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHSlider(
(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) TGHSlider(
(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 TGHSlider(
(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) TGHSlider(
(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 TGHSlider((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHSlider((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 TGHSlider((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHSlider((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHSlider[n];
       } else {
         p = new((void*) gvp) TGHSlider[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHSlider;
       } else {
         p = new((void*) gvp) TGHSlider;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_265_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHSlider G__TTGHSlider;
static int G__G__Gui2_265_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGHSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHSlider*) (soff+(sizeof(TGHSlider)*i)))->~G__TTGHSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHSlider*) (soff))->~G__TTGHSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSplitter */
static int G__G__Gui2_267_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitter*) G__getstructoffset())->SetFrame((TGFrame*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitter*) G__getstructoffset())->DragStarted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitter*) G__getstructoffset())->Moved((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGSplitter*) G__getstructoffset())->GetExternalHandler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitter*) G__getstructoffset())->SetExternalHandler((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSplitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSplitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSplitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSplitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSplitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_267_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSplitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSplitter G__TTGSplitter;
static int G__G__Gui2_267_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGSplitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSplitter*) (soff+(sizeof(TGSplitter)*i)))->~G__TTGSplitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSplitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSplitter*) (soff))->~G__TTGSplitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGVSplitter */
static int G__G__Gui2_268_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVSplitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGVSplitter(
(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) TGVSplitter(
(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 TGVSplitter(
(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) TGVSplitter(
(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 TGVSplitter(
(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) TGVSplitter(
(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 TGVSplitter((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGVSplitter((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 TGVSplitter((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGVSplitter((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVSplitter[n];
       } else {
         p = new((void*) gvp) TGVSplitter[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGVSplitter;
       } else {
         p = new((void*) gvp) TGVSplitter;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGVSplitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGVSplitter(
(TGWindow*) 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) TGVSplitter(
(TGWindow*) 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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGVSplitter*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGVSplitter*) G__getstructoffset())->GetLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGVSplitter*) G__getstructoffset())->IsLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGVSplitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVSplitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGVSplitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGVSplitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGVSplitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVSplitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVSplitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGVSplitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_268_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGVSplitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGVSplitter G__TTGVSplitter;
static int G__G__Gui2_268_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[] (TGVSplitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGVSplitter*) (soff+(sizeof(TGVSplitter)*i)))->~G__TTGVSplitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGVSplitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGVSplitter*) (soff))->~G__TTGVSplitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGHSplitter */
static int G__G__Gui2_269_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHSplitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGHSplitter(
(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) TGHSplitter(
(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 TGHSplitter(
(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) TGHSplitter(
(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 TGHSplitter(
(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) TGHSplitter(
(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 TGHSplitter((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGHSplitter((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 TGHSplitter((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGHSplitter((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHSplitter[n];
       } else {
         p = new((void*) gvp) TGHSplitter[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGHSplitter;
       } else {
         p = new((void*) gvp) TGHSplitter;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGHSplitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGHSplitter(
(TGWindow*) 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) TGHSplitter(
(TGWindow*) 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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGHSplitter*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGHSplitter*) G__getstructoffset())->GetAbove());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGHSplitter*) G__getstructoffset())->IsAbove());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGHSplitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHSplitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGHSplitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGHSplitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGHSplitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHSplitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHSplitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGHSplitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_269_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGHSplitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGHSplitter G__TTGHSplitter;
static int G__G__Gui2_269_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[] (TGHSplitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGHSplitter*) (soff+(sizeof(TGHSplitter)*i)))->~G__TTGHSplitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGHSplitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGHSplitter*) (soff))->~G__TTGHSplitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLVContainer */
static int G__G__Gui2_271_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVContainer(
(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) TGLVContainer(
(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 TGLVContainer(
(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) TGLVContainer(
(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 TGLVContainer(
(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) TGLVContainer(
(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__Gui2LN_TGLVContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVContainer(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLVContainer(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVContainer((TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLVContainer((TGCanvas*) 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 TGLVContainer((TGCanvas*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLVContainer((TGCanvas*) 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__Gui2LN_TGLVContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLVContainer*) G__getstructoffset())->GetListView());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->AddItem((TGLVEntry*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->SetListView((TGListView*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->RemoveItemWithData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->SetViewMode((EListViewMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLVContainer*) G__getstructoffset())->GetViewMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->SetColumns((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__Gui2_271_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGLVContainer*) G__getstructoffset())->GetMaxItemSize();
         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__Gui2_271_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLVContainer*) G__getstructoffset())->GetMaxSubnameWidth((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 12:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]), (const char*) G__int(libp->para[11]));
      G__setnull(result7);
      break;
   case 11:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]));
      G__setnull(result7);
      break;
   case 10:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLVContainer*) G__getstructoffset())->SetColHeaders();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLVContainer*) G__getstructoffset())->GetSelectedItems());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLVContainer*) G__getstructoffset())->GetMultipleSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLVContainer*) G__getstructoffset())->SetMultipleSelection((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLVContainer*) G__getstructoffset())->SetMultipleSelection();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->SetHeaders((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->SetHeader((const char*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->SetDefaultHeaders();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGLVContainer*) G__getstructoffset())->GetHeader((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLVContainer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVContainer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLVContainer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLVContainer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVContainer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVContainer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVContainer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVContainer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_271_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVContainer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLVContainer G__TTGLVContainer;
static int G__G__Gui2_271_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLVContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLVContainer*) (soff+(sizeof(TGLVContainer)*i)))->~G__TTGLVContainer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLVContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLVContainer*) (soff))->~G__TTGLVContainer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLVEntry */
static int G__G__Gui2_272_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]), (EListViewMode) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (Pixel_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]), (EListViewMode) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]), (Pixel_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]), (EListViewMode) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]), (EListViewMode) 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 TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]), (EListViewMode) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]), (EListViewMode) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3])
, (TGString**) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGString*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLVEntry((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLVEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLVEntry[n];
       } else {
         p = new((void*) gvp) TGLVEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLVEntry;
       } else {
         p = new((void*) gvp) TGLVEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (TGString**) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (TGString**) 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 TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (TGString**) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (TGString**) 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 TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (TGString**) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (TGString**) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) TGLVEntry(
(TGLVContainer*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVEntry*) G__getstructoffset())->SetViewMode((EListViewMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLVEntry*) G__getstructoffset())->GetItemName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVEntry*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVEntry*) G__getstructoffset())->SetItemName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLVEntry*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLVEntry*) G__getstructoffset())->GetViewMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVEntry*) G__getstructoffset())->SetUserData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TGLVEntry*) G__getstructoffset())->GetUserData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 12:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]), (const char*) G__int(libp->para[11]));
      G__setnull(result7);
      break;
   case 11:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]));
      G__setnull(result7);
      break;
   case 10:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLVEntry*) G__getstructoffset())->SetSubnames();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLVEntry*) G__getstructoffset())->SetPictures((TGPicture*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLVEntry*) G__getstructoffset())->SetPictures((TGPicture*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLVEntry*) G__getstructoffset())->SetPictures();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVEntry*) G__getstructoffset())->SetColumns((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__Gui2_272_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLVEntry*) G__getstructoffset())->SetCheckedEntry((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLVEntry*) G__getstructoffset())->SetCheckedEntry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLVEntry*) G__getstructoffset())->GetSubnameWidth((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLVEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLVEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLVEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_272_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLVEntry G__TTGLVEntry;
static int G__G__Gui2_272_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLVEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLVEntry*) (soff+(sizeof(TGLVEntry)*i)))->~G__TTGLVEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLVEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLVEntry*) (soff))->~G__TTGLVEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFileContainer */
static int G__G__Gui2_290_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileContainer(
(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) TGFileContainer(
(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 TGFileContainer(
(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) TGFileContainer(
(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 TGFileContainer(
(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) TGFileContainer(
(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 TGFileContainer((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFileContainer((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 TGFileContainer((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFileContainer((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFileContainer[n];
       } else {
         p = new((void*) gvp) TGFileContainer[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFileContainer;
       } else {
         p = new((void*) gvp) TGFileContainer;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileContainer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileContainer(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFileContainer(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileContainer((TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFileContainer((TGCanvas*) 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 TGFileContainer((TGCanvas*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFileContainer((TGCanvas*) 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__Gui2LN_TGFileContainer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->StopRefreshTimer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGFileContainer*) G__getstructoffset())->StartRefreshTimer((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGFileContainer*) G__getstructoffset())->StartRefreshTimer();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGFileContainer*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGFileContainer*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGFileContainer*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_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) ((TGFileContainer*) G__getstructoffset())->AddRemoteFile((TObject*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGFileContainer*) G__getstructoffset())->AddRemoteFile((TObject*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGFileContainer*) G__getstructoffset())->AddRemoteFile((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->Sort((EFSSortMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->SetFilter((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->ChangeDirectory((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->DisplayDirectory();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGFileContainer*) G__getstructoffset())->SetDisplayStat((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGFileContainer*) G__getstructoffset())->SetDisplayStat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGFileContainer*) G__getstructoffset())->GetDisplayStat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGFileContainer*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->GetFilePictures((const TGPicture**) G__int(libp->para[0]), (const TGPicture**) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFileContainer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileContainer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFileContainer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFileContainer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileContainer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileContainer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileContainer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileContainer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_290_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileContainer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFileContainer G__TTGFileContainer;
static int G__G__Gui2_290_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[] (TGFileContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFileContainer*) (soff+(sizeof(TGFileContainer)*i)))->~G__TTGFileContainer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFileContainer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFileContainer*) (soff))->~G__TTGFileContainer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFileItem */
static int G__G__Gui2_293_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileItem* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 14:
     //m: 14
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]), (EListViewMode) G__int(libp->para[11])
, (UInt_t) G__int(libp->para[12]), (Pixel_t) G__int(libp->para[13]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]), (EListViewMode) G__int(libp->para[11])
, (UInt_t) G__int(libp->para[12]), (Pixel_t) G__int(libp->para[13]));
     }
     break;
   case 13:
     //m: 13
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]), (EListViewMode) G__int(libp->para[11])
, (UInt_t) G__int(libp->para[12]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]), (EListViewMode) G__int(libp->para[11])
, (UInt_t) G__int(libp->para[12]));
     }
     break;
   case 12:
     //m: 12
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]), (EListViewMode) G__int(libp->para[11]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]), (EListViewMode) G__int(libp->para[11]));
     }
     break;
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Long_t) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Long64_t) G__Longlong(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) 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 TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) 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 TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFileItem((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFileItem((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFileItem[n];
       } else {
         p = new((void*) gvp) TGFileItem[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFileItem;
       } else {
         p = new((void*) gvp) TGFileItem;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileItem* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref, (EListViewMode) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Pixel_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref, (EListViewMode) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Pixel_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref, (EListViewMode) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref, (EListViewMode) 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 TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref, (EListViewMode) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref, (EListViewMode) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref);
     } else {
       p = new((void*) gvp) TGFileItem(
(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (TGString*) G__int(libp->para[5])
, *(FileStat_t*) libp->para[6].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGFileItem*) G__getstructoffset())->IsSymLink());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFileItem*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TGFileItem*) G__getstructoffset())->GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGFileItem*) G__getstructoffset())->GetModTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFileItem*) G__getstructoffset())->GetUid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGFileItem*) G__getstructoffset())->GetGid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGFileItem*) G__getstructoffset())->GetDNDdata((Atom_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileItem*) G__getstructoffset())->SetDNDData((TDNDData*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileItem*) G__getstructoffset())->SetDNDObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFileItem::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileItem::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFileItem::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFileItem::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileItem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileItem::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileItem::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileItem::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_293_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileItem::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFileItem G__TTGFileItem;
static int G__G__Gui2_293_0_32(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[] (TGFileItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFileItem*) (soff+(sizeof(TGFileItem)*i)))->~G__TTGFileItem();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFileItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFileItem*) (soff))->~G__TTGFileItem();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFSComboBox */
static int G__G__Gui2_298_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFSComboBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFSComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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) TGFSComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_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 TGFSComboBox(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFSComboBox(
(TGWindow*) 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 TGFSComboBox((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFSComboBox((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 TGFSComboBox((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFSComboBox((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFSComboBox[n];
       } else {
         p = new((void*) gvp) TGFSComboBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFSComboBox;
       } else {
         p = new((void*) gvp) TGFSComboBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFSComboBox*) G__getstructoffset())->Update((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFSComboBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFSComboBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFSComboBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFSComboBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFSComboBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFSComboBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFSComboBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFSComboBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_298_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFSComboBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFSComboBox G__TTGFSComboBox;
static int G__G__Gui2_298_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[] (TGFSComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFSComboBox*) (soff+(sizeof(TGFSComboBox)*i)))->~G__TTGFSComboBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFSComboBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFSComboBox*) (soff))->~G__TTGFSComboBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFileInfo */
static int G__G__Gui2_299_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileInfo[n];
     } else {
       p = new((void*) gvp) TGFileInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileInfo;
     } else {
       p = new((void*) gvp) TGFileInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_299_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileInfo*) G__getstructoffset())->SetMultipleSelection((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFileInfo G__TTGFileInfo;
static int G__G__Gui2_299_0_5(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[] (TGFileInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFileInfo*) (soff+(sizeof(TGFileInfo)*i)))->~G__TTGFileInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFileInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFileInfo*) (soff))->~G__TTGFileInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGFileDialog */
static int G__G__Gui2_300_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGFileDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (EFileDialogMode) G__int(libp->para[2]), (TGFileInfo*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGFileDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (EFileDialogMode) G__int(libp->para[2]), (TGFileInfo*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (EFileDialogMode) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGFileDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (EFileDialogMode) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGFileDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGFileDialog((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 TGFileDialog((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGFileDialog((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFileDialog[n];
       } else {
         p = new((void*) gvp) TGFileDialog[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGFileDialog;
       } else {
         p = new((void*) gvp) TGFileDialog;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGFileDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGFileDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGFileDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGFileDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGFileDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_300_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGFileDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGFileDialog G__TTGFileDialog;
static int G__G__Gui2_300_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[] (TGFileDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGFileDialog*) (soff+(sizeof(TGFileDialog)*i)))->~G__TTGFileDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGFileDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGFileDialog*) (soff))->~G__TTGFileDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGStatusBar */
static int G__G__Gui2_302_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGStatusBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGStatusBar(
(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) TGStatusBar(
(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 TGStatusBar(
(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) TGStatusBar(
(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 TGStatusBar(
(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) TGStatusBar(
(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 TGStatusBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGStatusBar((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 TGStatusBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGStatusBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGStatusBar[n];
       } else {
         p = new((void*) gvp) TGStatusBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGStatusBar;
       } else {
         p = new((void*) gvp) TGStatusBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGStatusBar*) G__getstructoffset())->SetText((TGString*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGStatusBar*) G__getstructoffset())->SetText((TGString*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGStatusBar*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGStatusBar*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGStatusBar*) G__getstructoffset())->AddText((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGStatusBar*) G__getstructoffset())->AddText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((const TGStatusBar*) G__getstructoffset())->GetText((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((const TGStatusBar*) G__getstructoffset())->GetText());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGStatusBar*) G__getstructoffset())->SetParts((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGStatusBar*) G__getstructoffset())->SetParts((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__Gui2_302_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGStatusBar*) G__getstructoffset())->Draw3DCorner((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGStatusBar*) G__getstructoffset())->GetBarPart((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGStatusBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGStatusBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGStatusBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGStatusBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGStatusBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGStatusBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGStatusBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGStatusBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_302_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGStatusBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGStatusBar G__TTGStatusBar;
static int G__G__Gui2_302_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[] (TGStatusBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGStatusBar*) (soff+(sizeof(TGStatusBar)*i)))->~G__TTGStatusBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGStatusBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGStatusBar*) (soff))->~G__TTGStatusBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ToolBarData_t */
// automatic default constructor
static int G__G__Gui2_307_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ToolBarData_t *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ToolBarData_t[n];
     } else {
       p = new((void*) gvp) ToolBarData_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ToolBarData_t;
     } else {
       p = new((void*) gvp) ToolBarData_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_ToolBarData_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui2_307_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ToolBarData_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ToolBarData_t(*(ToolBarData_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_ToolBarData_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ToolBarData_t G__TToolBarData_t;
static int G__G__Gui2_307_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ToolBarData_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ToolBarData_t*) (soff+(sizeof(ToolBarData_t)*i)))->~G__TToolBarData_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ToolBarData_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ToolBarData_t*) (soff))->~G__TToolBarData_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGToolBar */
static int G__G__Gui2_308_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGToolBar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGToolBar(
(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) TGToolBar(
(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 TGToolBar(
(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) TGToolBar(
(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 TGToolBar(
(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) TGToolBar(
(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 TGToolBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGToolBar((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 TGToolBar((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGToolBar((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGToolBar[n];
       } else {
         p = new((void*) gvp) TGToolBar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGToolBar;
       } else {
         p = new((void*) gvp) TGToolBar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGToolBar*) G__getstructoffset())->AddButton((TGWindow*) G__int(libp->para[0]), (ToolBarData_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGToolBar*) G__getstructoffset())->AddButton((TGWindow*) G__int(libp->para[0]), (ToolBarData_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGToolBar*) G__getstructoffset())->AddButton((TGWindow*) G__int(libp->para[0]), (TGPictureButton*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGToolBar*) G__getstructoffset())->AddButton((TGWindow*) G__int(libp->para[0]), (TGPictureButton*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->ChangeIcon((ToolBarData_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__Gui2_308_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGToolBar*) G__getstructoffset())->GetButton((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGToolBar*) G__getstructoffset())->GetId((TGButton*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->SetId((TGButton*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->ButtonPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->ButtonReleased();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->ButtonClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->Pressed((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->Released((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->Clicked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGToolBar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGToolBar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGToolBar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGToolBar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGToolBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGToolBar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGToolBar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGToolBar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_308_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGToolBar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGToolBar G__TTGToolBar;
static int G__G__Gui2_308_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[] (TGToolBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGToolBar*) (soff+(sizeof(TGToolBar)*i)))->~G__TTGToolBar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGToolBar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGToolBar*) (soff))->~G__TTGToolBar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListTreeItem */
static int G__G__Gui2_309_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetParent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetFirstChild());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetLastChild());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetPrevSibling());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetNextSibling());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->IsOpen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetOpen((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGListTreeItem*) G__getstructoffset())->GetActiveColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->Rename((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGListTreeItem*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListTreeItem*) G__getstructoffset())->GetTextLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGListTreeItem*) G__getstructoffset())->GetTipText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListTreeItem*) G__getstructoffset())->GetTipTextLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetTipText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGListTreeItem*) G__getstructoffset())->SetUserData((void*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGListTreeItem*) G__getstructoffset())->SetUserData((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TGListTreeItem*) G__getstructoffset())->GetUserData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetPictures((TGPicture*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->GetCheckBoxPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetCheckBoxPictures((TGPicture*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGListTreeItem*) G__getstructoffset())->GetPicWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTreeItem*) G__getstructoffset())->SetCheckBox((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTreeItem*) G__getstructoffset())->SetCheckBox();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->HasCheckBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTreeItem*) G__getstructoffset())->CheckItem((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTreeItem*) G__getstructoffset())->CheckItem();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->Toggle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->IsChecked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTreeItem*) G__getstructoffset())->CheckAllChildren((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTreeItem*) G__getstructoffset())->CheckAllChildren();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->CheckChildren((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TGListTreeItem*) G__getstructoffset())->HasCheckedChild((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TGListTreeItem*) G__getstructoffset())->HasCheckedChild());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TGListTreeItem*) G__getstructoffset())->HasUnCheckedChild((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TGListTreeItem*) G__getstructoffset())->HasUnCheckedChild());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->UpdateState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->HasColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGListTreeItem*) G__getstructoffset())->GetColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->ClearColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetDNDSource((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SetDNDTarget((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->IsDNDSource());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->IsDNDTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTreeItem*) G__getstructoffset())->HandlesDragAndDrop());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->HandleDrag();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->HandleDrop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->SavePrimitive(*(ostream*) libp->para[0].ref, (Option_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__Gui2_309_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTreeItem::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTreeItem::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListTreeItem::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListTreeItem::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTreeItem*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTreeItem::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListTreeItem::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTreeItem::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_309_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListTreeItem::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListTreeItem G__TTGListTreeItem;
static int G__G__Gui2_309_0_62(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[] (TGListTreeItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListTreeItem*) (soff+(sizeof(TGListTreeItem)*i)))->~G__TTGListTreeItem();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListTreeItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListTreeItem*) (soff))->~G__TTGListTreeItem();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListTree */
static int G__G__Gui2_310_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListTree* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTree(
(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) TGListTree(
(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 TGListTree(
(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) TGListTree(
(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 TGListTree(
(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) TGListTree(
(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 TGListTree((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGListTree((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 TGListTree((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGListTree((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGListTree[n];
       } else {
         p = new((void*) gvp) TGListTree[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGListTree;
       } else {
         p = new((void*) gvp) TGListTree;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGListTree));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListTree* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTree(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGListTree(
(TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTree((TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGListTree((TGCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGListTree));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetCanvas((TGCanvas*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGListTree*) G__getstructoffset())->DrawOutline((Handle_t) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGListTree*) G__getstructoffset())->DrawOutline((Handle_t) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])
, (Pixel_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGListTree*) G__getstructoffset())->DrawOutline((Handle_t) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->DrawActive((Handle_t) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (TGPicture*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->AddItem((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->RenameItem((TGListTreeItem*) 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__Gui2_310_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->DeleteItem((TGListTreeItem*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->OpenItem((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->CloseItem((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGListTree*) G__getstructoffset())->CheckItem((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGListTree*) G__getstructoffset())->CheckItem((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGListTree*) G__getstructoffset())->SetCheckBox((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGListTree*) G__getstructoffset())->SetCheckBox((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->ToggleItem((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->RecursiveDeleteItem((TGListTreeItem*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->DeleteChildren((TGListTreeItem*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->Reparent((TGListTreeItem*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->ReparentChildren((TGListTreeItem*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetToolTipItem((TGListTreeItem*) 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__Gui2_310_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTree*) G__getstructoffset())->SetAutoTips((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTree*) G__getstructoffset())->SetAutoTips();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetAutoCheckBoxPic((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetSelected((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->AdjustPosition((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->Sort((TGListTreeItem*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->SortSiblings((TGListTreeItem*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->SortChildren((TGListTreeItem*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->HighlightItem((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->ClearHighlighted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGListTree*) G__getstructoffset())->GetPathnameFromItem((TGListTreeItem*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGListTree*) G__getstructoffset())->GetPathnameFromItem((TGListTreeItem*) G__int(libp->para[0]), (char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->UnselectAll((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_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__Gui2_310_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->HighlightItem((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->HighlightChildren((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTree*) G__getstructoffset())->DisableOpen((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTree*) G__getstructoffset())->DisableOpen();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->GetChecked((TList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->GetCheckedChildren((TList*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->CheckAllChildren((TGListTreeItem*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTree*) G__getstructoffset())->GetFirstItem());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTree*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTree*) G__getstructoffset())->GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGListTree*) G__getstructoffset())->GetBelowMouse());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->FindSiblingByName((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->FindSiblingByData((TGListTreeItem*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->FindChildByName((TGListTreeItem*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->FindChildByData((TGListTreeItem*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->FindItemByPathname((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGListTree*) G__getstructoffset())->FindItemByObj((TGListTreeItem*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->AddItem((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->AddRoot((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->DeleteSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->RenameSelected((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->MouseOver((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->MouseOver((TGListTreeItem*) 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__Gui2_310_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->KeyPressed((TGListTreeItem*) 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__Gui2_310_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->ReturnPressed((TGListTreeItem*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->Clicked((TGListTreeItem*) 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__Gui2_310_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->Clicked((TGListTreeItem*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->Clicked((TGListTreeItem*) G__int(libp->para[0]), (Int_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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->DoubleClicked((TGListTreeItem*) 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__Gui2_310_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->DoubleClicked((TGListTreeItem*) 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);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->Checked((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->DataDropped((TGListTreeItem*) G__int(libp->para[0]), (TDNDData*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->FontHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->FontAscent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGListTree*) G__getstructoffset())->TextWidth((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTree::GetOpenPic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTree::GetClosedPic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTree::GetCheckedPic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTree::GetUncheckedPic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTree*) G__getstructoffset())->SetUserControl((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTree*) G__getstructoffset())->SetUserControl();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTree*) G__getstructoffset())->HasUserControl());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGListTree*) G__getstructoffset())->SetEventHandled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGListTree*) G__getstructoffset())->SetEventHandled();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGListTree*) G__getstructoffset())->IsEventHandled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListTree*) G__getstructoffset())->GetColorMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetColorMode((TGListTree::EColorMarkupMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGListTree*) G__getstructoffset())->GetCheckMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->SetCheckMode((TGListTree::ECheckMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTree::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTree::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListTree::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListTree::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTree*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTree::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListTree::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTree::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_310_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListTree::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListTree G__TTGListTree;
static int G__G__Gui2_310_0_146(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[] (TGListTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListTree*) (soff+(sizeof(TGListTree)*i)))->~G__TTGListTree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListTree*) (soff))->~G__TTGListTree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGListTreeItemStd */
static int G__G__Gui2_311_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGListTreeItemStd* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTreeItemStd(
(TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGListTreeItemStd(
(TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTreeItemStd(
(TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGListTreeItemStd(
(TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (TGPicture*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTreeItemStd(
(TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGListTreeItemStd(
(TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGListTreeItemStd((TGClient*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGListTreeItemStd((TGClient*) 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 TGListTreeItemStd((TGClient*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGListTreeItemStd((TGClient*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGListTreeItemStd[n];
       } else {
         p = new((void*) gvp) TGListTreeItemStd[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGListTreeItemStd;
       } else {
         p = new((void*) gvp) TGListTreeItemStd;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGListTreeItemStd::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTreeItemStd::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGListTreeItemStd::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGListTreeItemStd::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGListTreeItemStd*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTreeItemStd::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListTreeItemStd::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGListTreeItemStd::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_311_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGListTreeItemStd::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGListTreeItemStd G__TTGListTreeItemStd;
static int G__G__Gui2_311_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGListTreeItemStd*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGListTreeItemStd*) (soff+(sizeof(TGListTreeItemStd)*i)))->~G__TTGListTreeItemStd();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGListTreeItemStd*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGListTreeItemStd*) (soff))->~G__TTGListTreeItemStd();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextLine */
static int G__G__Gui2_314_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextLine[n];
     } else {
       p = new((void*) gvp) TGTextLine[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextLine;
     } else {
       p = new((void*) gvp) TGTextLine;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGTextLine((TGTextLine*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGTextLine((TGTextLine*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGTextLine((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGTextLine((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__Gui2LN_TGTextLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TGTextLine*) G__getstructoffset())->GetLineLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->DelText((ULong_t) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->InsText((ULong_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__Gui2_314_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGTextLine*) G__getstructoffset())->GetText((ULong_t) G__int(libp->para[0]), (ULong_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGTextLine*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGTextLine*) G__getstructoffset())->GetWord((ULong_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->DelChar((ULong_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->InsChar((ULong_t) G__int(libp->para[0]), (char) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((TGTextLine*) G__getstructoffset())->GetChar((ULong_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextLine::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextLine::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextLine::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextLine::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextLine*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextLine*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextLine::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextLine::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextLine::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_314_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextLine::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextLine G__TTGTextLine;
static int G__G__Gui2_314_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGTextLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextLine*) (soff+(sizeof(TGTextLine)*i)))->~G__TTGTextLine();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextLine*) (soff))->~G__TTGTextLine();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGText */
static int G__G__Gui2_315_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGText* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGText[n];
     } else {
       p = new((void*) gvp) TGText[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGText;
     } else {
       p = new((void*) gvp) TGText;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGText* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGText((TGText*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGText((TGText*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGText* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGText((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGText((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__Gui2LN_TGText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGText*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Load((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->LoadBuffer((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Save((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Append((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGText*) G__getstructoffset())->IsSaved());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGText*) G__getstructoffset())->GetFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->DelChar(*((TGLongPosition*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->InsChar(*((TGLongPosition*) G__int(libp->para[0])), (char) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((TGText*) G__getstructoffset())->GetChar(*((TGLongPosition*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->DelText(*((TGLongPosition*) G__int(libp->para[0])), *((TGLongPosition*) G__int(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->InsText(*((TGLongPosition*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->InsText(*((TGLongPosition*) G__int(libp->para[0])), (TGText*) G__int(libp->para[1])
, *((TGLongPosition*) G__int(libp->para[2])), *((TGLongPosition*) G__int(libp->para[3]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->AddText((TGText*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->DelLine((ULong_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TGText*) G__getstructoffset())->GetLine(*((TGLongPosition*) G__int(libp->para[0])), (ULong_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TGText*) G__getstructoffset())->AsString();
         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__Gui2_315_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGText*) G__getstructoffset())->GetCurrentLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->BreakLine(*((TGLongPosition*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->InsLine((ULong_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGText*) G__getstructoffset())->RowCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGText*) G__getstructoffset())->ColCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGText*) G__getstructoffset())->GetLineLength((Long_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const TGText*) G__getstructoffset())->GetLongestLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGText*) G__getstructoffset())->ReTab((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Search((TGLongPosition*) G__int(libp->para[0]), *((TGLongPosition*) G__int(libp->para[1]))
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGText*) G__getstructoffset())->Replace(*((TGLongPosition*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGText::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGText::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGText::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGText::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGText*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGText*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGText*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGText::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGText::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGText::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_315_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGText::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGText G__TTGText;
static int G__G__Gui2_315_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGText*) (soff+(sizeof(TGText)*i)))->~G__TTGText();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGText*) (soff))->~G__TTGText();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGViewFrame */
static int G__G__Gui2_325_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGViewFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGViewFrame(
(TGView*) 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) TGViewFrame(
(TGView*) 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 TGViewFrame(
(TGView*) 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) TGViewFrame(
(TGView*) 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 TGViewFrame(
(TGView*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGViewFrame(
(TGView*) 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__Gui2LN_TGViewFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGViewFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGViewFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGViewFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGViewFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGViewFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGViewFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGViewFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGViewFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_325_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGViewFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGViewFrame G__TTGViewFrame;
static int G__G__Gui2_325_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[] (TGViewFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGViewFrame*) (soff+(sizeof(TGViewFrame)*i)))->~G__TTGViewFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGViewFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGViewFrame*) (soff))->~G__TTGViewFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGView */
static int G__G__Gui2_326_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGView(
(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])
, (UInt_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])
, (Pixel_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGView(
(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])
, (UInt_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])
, (Pixel_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGView(
(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])
, (UInt_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) TGView(
(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])
, (UInt_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 TGView(
(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])
, (UInt_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) TGView(
(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])
, (UInt_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 TGView(
(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])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGView(
(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])
, (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 TGView(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGView(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGView(
(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) TGView(
(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 TGView(
(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) TGView(
(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 TGView((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGView((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 TGView((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGView((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGView[n];
       } else {
         p = new((void*) gvp) TGView[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGView;
       } else {
         p = new((void*) gvp) TGView;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGView*) G__getstructoffset())->GetCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->SetVisibleStart((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__Gui2_326_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->ScrollCanvas((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__Gui2_326_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->DrawRegion((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__Gui2_326_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->ScrollToPosition(*((TGLongPosition*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->ScrollUp((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->ScrollDown((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->ScrollLeft((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->ScrollRight((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGView*) G__getstructoffset())->GetVirtualSize();
         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__Gui2_326_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGView*) G__getstructoffset())->GetScrollValue();
         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__Gui2_326_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGView*) G__getstructoffset())->GetScrollPosition();
         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__Gui2_326_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGView*) G__getstructoffset())->ToVirtual(*((TGLongPosition*) G__int(libp->para[0])));
         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__Gui2_326_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGView*) G__getstructoffset())->ToPhysical(*((TGLongPosition*) G__int(libp->para[0])));
         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__Gui2_326_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->UpdateBackgroundStart();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = ((TGView*) G__getstructoffset())->GetViewWhiteGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGView::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGView::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGView::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGView::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGView::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGView::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGView::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_326_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGView::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGView G__TTGView;
static int G__G__Gui2_326_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[] (TGView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGView*) (soff+(sizeof(TGView)*i)))->~G__TTGView();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGView*) (soff))->~G__TTGView();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextView */
static int G__G__Gui2_329_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextView(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextView(
(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])
, (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 TGTextView(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextView(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextView(
(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) TGTextView(
(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 TGTextView(
(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) TGTextView(
(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 TGTextView((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextView((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 TGTextView((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextView((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextView[n];
       } else {
         p = new((void*) gvp) TGTextView[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextView;
       } else {
         p = new((void*) gvp) TGTextView;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTextView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_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) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_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 TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_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 TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) 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 TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) 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__Gui2LN_TGTextView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextView* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_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) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_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 TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_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 TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) 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 TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextView(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) 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__Gui2LN_TGTextView));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->IsSaved());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ToObjXCoord((Long_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ToObjYCoord((Long_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ToScrXCoord((Long_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ToScrYCoord((Long_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->AdjustWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->LoadFile((const char*) G__int(libp->para[0]), (long) G__int(libp->para[1])
, (long) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->LoadFile((const char*) G__int(libp->para[0]), (long) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->LoadFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->LoadBuffer((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->Copy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->SelectAll());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextView*) G__getstructoffset())->Search((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetFont((FontStruct_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ReturnHeighestColHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ReturnLongestLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ReturnLineLength((Long_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ReturnLongestLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((TGTextView*) G__getstructoffset())->ReturnLineCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetSBRange((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetHsbPosition((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetVsbPosition((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->ShowBottom();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->ShowTop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetText((TGText*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->AddText((TGText*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->AddLine((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->AddLineFast((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->Update();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetBackground((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetSelectBack((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->SetSelectFore((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextView*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextView*) G__getstructoffset())->SetReadOnly((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextView*) G__getstructoffset())->SetReadOnly();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextView*) G__getstructoffset())->IsReadOnly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextView*) G__getstructoffset())->IsMarked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->DataChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->DataDropped((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->Marked((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->Clicked((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->DoubleClicked((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextView::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextView::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextView::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextView::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextView::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextView::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextView::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_329_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextView::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextView G__TTGTextView;
static int G__G__Gui2_329_0_83(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[] (TGTextView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextView*) (soff+(sizeof(TGTextView)*i)))->~G__TTGTextView();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextView*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextView*) (soff))->~G__TTGTextView();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSearchType */
static int G__G__Gui2_330_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSearchType* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSearchType[n];
     } else {
       p = new((void*) gvp) TGSearchType[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSearchType;
     } else {
       p = new((void*) gvp) TGSearchType;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui2_330_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGSearchType* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGSearchType(*(TGSearchType*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSearchType G__TTGSearchType;
static int G__G__Gui2_330_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGSearchType*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSearchType*) (soff+(sizeof(TGSearchType)*i)))->~G__TTGSearchType();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSearchType*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSearchType*) (soff))->~G__TTGSearchType();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Gui2_330_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSearchType* dest = (TGSearchType*) G__getstructoffset();
   *dest = *(TGSearchType*) libp->para[0].ref;
   const TGSearchType& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTextEdit */
static int G__G__Gui2_332_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEdit* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEdit(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(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])
, (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 TGTextEdit(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEdit(
(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) TGTextEdit(
(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 TGTextEdit(
(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) TGTextEdit(
(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 TGTextEdit((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTextEdit((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 TGTextEdit((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTextEdit((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextEdit[n];
       } else {
         p = new((void*) gvp) TGTextEdit[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTextEdit;
       } else {
         p = new((void*) gvp) TGTextEdit;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEdit* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_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) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_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 TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_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 TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) 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 TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (TGText*) 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__Gui2LN_TGTextEdit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTextEdit* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_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) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_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 TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_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 TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) 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 TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTextEdit(
(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (const char*) 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__Gui2LN_TGTextEdit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->SaveFile((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->SaveFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Cut());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Paste());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->InsChar((char) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->DelChar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->BreakLine();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->PrevChar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->NextChar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->LineUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->LineDown();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->ScreenUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->ScreenDown();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->Home();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->End();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Search((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Search((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Search((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->Search((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Replace(*((TGLongPosition*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Goto((Long_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGTextEdit*) G__getstructoffset())->Goto((Long_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEdit*) G__getstructoffset())->SetInsertMode((TGTextEdit::EInsertMode) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEdit*) G__getstructoffset())->SetInsertMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGTextEdit*) G__getstructoffset())->GetInsertMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextEdit*) G__getstructoffset())->GetMenu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEdit*) G__getstructoffset())->EnableMenu((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEdit*) G__getstructoffset())->EnableMenu();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextEdit*) G__getstructoffset())->IsMenuEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTextEdit*) G__getstructoffset())->GetHistory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTextEdit*) G__getstructoffset())->EnableCursorWithoutFocus((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTextEdit*) G__getstructoffset())->EnableCursorWithoutFocus();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGTextEdit*) G__getstructoffset())->IsCursorEnabledithoutFocus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->SetFocus();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->SetCurrent(*((TGLongPosition*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLongPosition* pobj;
         const TGLongPosition xobj = ((const TGTextEdit*) G__getstructoffset())->GetCurrentPos();
         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__Gui2_332_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->FindAgain();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->Closed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->Opened();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->Saved();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->SavedAs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTextEdit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEdit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTextEdit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTextEdit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTextEdit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEdit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextEdit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTextEdit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_332_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTextEdit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTextEdit G__TTGTextEdit;
static int G__G__Gui2_332_0_78(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[] (TGTextEdit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTextEdit*) (soff+(sizeof(TGTextEdit)*i)))->~G__TTGTextEdit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTextEdit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTextEdit*) (soff))->~G__TTGTextEdit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGSearchDialog */
static int G__G__Gui2_336_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGSearchDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSearchDialog(
(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])
, (TGSearchType*) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (UInt_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGSearchDialog(
(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])
, (TGSearchType*) G__int(libp->para[4]), (Int_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 TGSearchDialog(
(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])
, (TGSearchType*) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGSearchDialog(
(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])
, (TGSearchType*) 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 TGSearchDialog(
(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])
, (TGSearchType*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGSearchDialog(
(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])
, (TGSearchType*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGSearchDialog(
(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) TGSearchDialog(
(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 TGSearchDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGSearchDialog(
(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 TGSearchDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGSearchDialog((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 TGSearchDialog((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGSearchDialog((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSearchDialog[n];
       } else {
         p = new((void*) gvp) TGSearchDialog[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGSearchDialog;
       } else {
         p = new((void*) gvp) TGSearchDialog;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSearchDialog*) G__getstructoffset())->SetClose((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGSearchDialog*) G__getstructoffset())->IsClose());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSearchDialog*) G__getstructoffset())->TextEntered((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGSearchDialog*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TGSearchDialog*& obj = TGSearchDialog::SearchDialog();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGSearchDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSearchDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGSearchDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGSearchDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGSearchDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSearchDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSearchDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGSearchDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_336_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGSearchDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGSearchDialog G__TTGSearchDialog;
static int G__G__Gui2_336_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[] (TGSearchDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGSearchDialog*) (soff+(sizeof(TGSearchDialog)*i)))->~G__TTGSearchDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGSearchDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGSearchDialog*) (soff))->~G__TTGSearchDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGPrintDialog */
static int G__G__Gui2_337_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGPrintDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]), (char**) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (UInt_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]), (char**) 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 TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]), (char**) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]), (char**) 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 TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]), (char**) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]), (char**) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGPrintDialog(
(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])
, (char**) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGPrintDialog(
(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) TGPrintDialog(
(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 TGPrintDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGPrintDialog(
(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 TGPrintDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGPrintDialog((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 TGPrintDialog((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGPrintDialog((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPrintDialog[n];
       } else {
         p = new((void*) gvp) TGPrintDialog[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGPrintDialog;
       } else {
         p = new((void*) gvp) TGPrintDialog;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGPrintDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPrintDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGPrintDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGPrintDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGPrintDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPrintDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPrintDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGPrintDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_337_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGPrintDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGPrintDialog G__TTGPrintDialog;
static int G__G__Gui2_337_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[] (TGPrintDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGPrintDialog*) (soff+(sizeof(TGPrintDialog)*i)))->~G__TTGPrintDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGPrintDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGPrintDialog*) (soff))->~G__TTGPrintDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGGotoDialog */
static int G__G__Gui2_338_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGGotoDialog* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGotoDialog(
(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])
, (Long_t*) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGGotoDialog(
(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])
, (Long_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 TGGotoDialog(
(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])
, (Long_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGGotoDialog(
(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])
, (Long_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGGotoDialog(
(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) TGGotoDialog(
(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 TGGotoDialog(
(TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGGotoDialog(
(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 TGGotoDialog((TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGGotoDialog((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 TGGotoDialog((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGGotoDialog((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGGotoDialog[n];
       } else {
         p = new((void*) gvp) TGGotoDialog[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGGotoDialog;
       } else {
         p = new((void*) gvp) TGGotoDialog;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGGotoDialog::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGotoDialog::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGGotoDialog::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGGotoDialog::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGGotoDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGotoDialog::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGGotoDialog::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGGotoDialog::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_338_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGGotoDialog::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGGotoDialog G__TTGGotoDialog;
static int G__G__Gui2_338_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[] (TGGotoDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGGotoDialog*) (soff+(sizeof(TGGotoDialog)*i)))->~G__TTGGotoDialog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGGotoDialog*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGGotoDialog*) (soff))->~G__TTGGotoDialog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDoubleSlider */
static int G__G__Gui2_341_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) G__getstructoffset())->SetScale((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) 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__Gui2_341_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) G__getstructoffset())->SetPosition((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__Gui2_341_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGDoubleSlider*) G__getstructoffset())->GetMinPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGDoubleSlider*) G__getstructoffset())->GetMaxPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGDoubleSlider*) G__getstructoffset())->GetPosition(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGDoubleSlider*) G__getstructoffset())->GetPosition((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) G__getstructoffset())->PositionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) G__getstructoffset())->Pressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) G__getstructoffset())->Released();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDoubleSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDoubleSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDoubleSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDoubleSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_341_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDoubleSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDoubleSlider G__TTGDoubleSlider;
static int G__G__Gui2_341_0_32(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[] (TGDoubleSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDoubleSlider*) (soff+(sizeof(TGDoubleSlider)*i)))->~G__TTGDoubleSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDoubleSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDoubleSlider*) (soff))->~G__TTGDoubleSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDoubleVSlider */
static int G__G__Gui2_342_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDoubleVSlider* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGDoubleVSlider(
(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])
, (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 TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGDoubleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleVSlider(
(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) TGDoubleVSlider(
(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 TGDoubleVSlider(
(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) TGDoubleVSlider(
(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 TGDoubleVSlider((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGDoubleVSlider((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 TGDoubleVSlider((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGDoubleVSlider((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDoubleVSlider[n];
       } else {
         p = new((void*) gvp) TGDoubleVSlider[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDoubleVSlider;
       } else {
         p = new((void*) gvp) TGDoubleVSlider;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDoubleVSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleVSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDoubleVSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDoubleVSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleVSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleVSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDoubleVSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleVSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_342_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDoubleVSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDoubleVSlider G__TTGDoubleVSlider;
static int G__G__Gui2_342_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[] (TGDoubleVSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDoubleVSlider*) (soff+(sizeof(TGDoubleVSlider)*i)))->~G__TTGDoubleVSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDoubleVSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDoubleVSlider*) (soff))->~G__TTGDoubleVSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGDoubleHSlider */
static int G__G__Gui2_343_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGDoubleHSlider* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGDoubleHSlider(
(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])
, (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 TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGDoubleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGDoubleHSlider(
(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) TGDoubleHSlider(
(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 TGDoubleHSlider(
(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) TGDoubleHSlider(
(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 TGDoubleHSlider((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGDoubleHSlider((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 TGDoubleHSlider((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGDoubleHSlider((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDoubleHSlider[n];
       } else {
         p = new((void*) gvp) TGDoubleHSlider[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGDoubleHSlider;
       } else {
         p = new((void*) gvp) TGDoubleHSlider;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGDoubleHSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleHSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGDoubleHSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGDoubleHSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGDoubleHSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleHSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDoubleHSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGDoubleHSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_343_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGDoubleHSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGDoubleHSlider G__TTGDoubleHSlider;
static int G__G__Gui2_343_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[] (TGDoubleHSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGDoubleHSlider*) (soff+(sizeof(TGDoubleHSlider)*i)))->~G__TTGDoubleHSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGDoubleHSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGDoubleHSlider*) (soff))->~G__TTGDoubleHSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTreeLBEntry */
static int G__G__Gui2_344_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TGTreeLBEntry::GetDefaultFontStruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGGC& obj = TGTreeLBEntry::GetDefaultGC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTreeLBEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) 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])
, (Pixel_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) 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])
, (Pixel_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) 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) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) 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 TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5])
, (FontStruct_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) 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 TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) G__int(libp->para[4]), (GContext_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) 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 TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (TGString*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) 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 TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry(
(TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1])
, (TGPicture*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTreeLBEntry((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry((TGWindow*) G__int(libp->para[0]), (TGString*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTreeLBEntry((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTreeLBEntry((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTreeLBEntry[n];
       } else {
         p = new((void*) gvp) TGTreeLBEntry[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTreeLBEntry;
       } else {
         p = new((void*) gvp) TGTreeLBEntry;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTreeLBEntry*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTreeLBEntry*) G__getstructoffset())->GetPicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGTreeLBEntry*) G__getstructoffset())->GetPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTreeLBEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTreeLBEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTreeLBEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTreeLBEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTreeLBEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTreeLBEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTreeLBEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTreeLBEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_344_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTreeLBEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTreeLBEntry G__TTGTreeLBEntry;
static int G__G__Gui2_344_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGTreeLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTreeLBEntry*) (soff+(sizeof(TGTreeLBEntry)*i)))->~G__TTGTreeLBEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTreeLBEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTreeLBEntry*) (soff))->~G__TTGTreeLBEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRegion */
static int G__G__Gui2_347_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion[n];
     } else {
       p = new((void*) gvp) TGRegion[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion;
     } else {
       p = new((void*) gvp) TGRegion;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion(
(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])
, (TGRegion::ERegionType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGRegion(
(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])
, (TGRegion::ERegionType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion(
(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) TGRegion(
(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]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion(
(Int_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRegion(
(Int_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion((Int_t) G__int(libp->para[0]), (TPoint*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGRegion((Int_t) G__int(libp->para[0]), (TPoint*) 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__Gui2LN_TGRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion(
(Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGRegion(
(Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_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 TGRegion(
(Int_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) TGRegion(
(Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_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__Gui2LN_TGRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion(
*(TArrayS*) libp->para[0].ref, *(TArrayS*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRegion(
*(TArrayS*) libp->para[0].ref, *(TArrayS*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegion(*(TArrayS*) libp->para[0].ref, *(TArrayS*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TGRegion(*(TArrayS*) libp->para[0].ref, *(TArrayS*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRegion(*(TGRegion*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGRegion(*(TGRegion*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRegion*) G__getstructoffset())->Contains(*(TPoint*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRegion*) 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__Gui2_347_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->Unite(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->Intersect(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->Subtract(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->Eor(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGDimension* pobj;
         const TGDimension xobj = ((const TGRegion*) G__getstructoffset())->GetDimension();
         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__Gui2_347_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGPosition* pobj;
         const TGPosition xobj = ((const TGRegion*) G__getstructoffset())->GetPosition();
         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__Gui2_347_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRegion*) G__getstructoffset())->IsNull());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRegion*) G__getstructoffset())->IsEmpty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->operator|(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->operator+(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->operator&(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->operator-(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion* pobj;
         const TGRegion xobj = ((const TGRegion*) G__getstructoffset())->operator^(*(TGRegion*) libp->para[0].ref);
         pobj = new TGRegion(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__Gui2_347_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion& obj = ((TGRegion*) G__getstructoffset())->operator|=(*(TGRegion*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion& obj = ((TGRegion*) G__getstructoffset())->operator+=(*(TGRegion*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion& obj = ((TGRegion*) G__getstructoffset())->operator&=(*(TGRegion*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion& obj = ((TGRegion*) G__getstructoffset())->operator-=(*(TGRegion*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion& obj = ((TGRegion*) G__getstructoffset())->operator^=(*(TGRegion*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRegion*) G__getstructoffset())->operator==(*(TGRegion*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGRegion*) G__getstructoffset())->operator!=(*(TGRegion*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGRegion& obj = ((TGRegion*) G__getstructoffset())->operator=(*(TGRegion*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRegion::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRegion::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRegion::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRegion::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRegion*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRegion::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRegion::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRegion::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_347_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRegion::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRegion G__TTGRegion;
static int G__G__Gui2_347_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[] (TGRegion*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRegion*) (soff+(sizeof(TGRegion)*i)))->~G__TTGRegion();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRegion*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRegion*) (soff))->~G__TTGRegion();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGRegionWithId */
static int G__G__Gui2_349_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegionWithId* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegionWithId[n];
     } else {
       p = new((void*) gvp) TGRegionWithId[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegionWithId;
     } else {
       p = new((void*) gvp) TGRegionWithId;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegionWithId* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegionWithId(
(Int_t) 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]), (TGRegion::ERegionType) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGRegionWithId(
(Int_t) 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]), (TGRegion::ERegionType) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegionWithId(
(Int_t) 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) TGRegionWithId(
(Int_t) 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;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegionWithId* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGRegionWithId(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TPoint*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGRegionWithId(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TPoint*) 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 TGRegionWithId(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TPoint*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGRegionWithId(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TPoint*) 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__Gui2LN_TGRegionWithId));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegionWithId* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRegionWithId(*(TGRegionWithId*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGRegionWithId(*(TGRegionWithId*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGRegionWithId* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGRegionWithId(*(TGRegion*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGRegionWithId(*(TGRegion*) libp->para[0].ref, (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__Gui2LN_TGRegionWithId));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGRegionWithId*) G__getstructoffset())->GetId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGRegionWithId*) G__getstructoffset())->GetToolTipText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRegionWithId*) G__getstructoffset())->SetToolTipText((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (TGFrame*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGRegionWithId*) G__getstructoffset())->GetPopup());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRegionWithId*) G__getstructoffset())->SetPopup((TGPopupMenu*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRegionWithId*) G__getstructoffset())->DisplayPopup();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGRegionWithId::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRegionWithId::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGRegionWithId::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGRegionWithId::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGRegionWithId*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRegionWithId::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRegionWithId::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGRegionWithId::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_349_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGRegionWithId::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGRegionWithId G__TTGRegionWithId;
static int G__G__Gui2_349_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[] (TGRegionWithId*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGRegionWithId*) (soff+(sizeof(TGRegionWithId)*i)))->~G__TTGRegionWithId();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGRegionWithId*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGRegionWithId*) (soff))->~G__TTGRegionWithId();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGImageMap */
static int G__G__Gui2_350_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGImageMap* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGImageMap((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGImageMap((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGImageMap((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGImageMap((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGImageMap[n];
       } else {
         p = new((void*) gvp) TGImageMap[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGImageMap;
       } else {
         p = new((void*) gvp) TGImageMap;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGImageMap* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGImageMap((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGImageMap((TGWindow*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGImageMap*) G__getstructoffset())->GetNavMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->AddRegion(*(TGRegion*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGImageMap*) G__getstructoffset())->CreatePopup((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGImageMap*) G__getstructoffset())->GetPopup((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGImageMap*) G__getstructoffset())->SetToolTipText((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGImageMap*) G__getstructoffset())->SetToolTipText((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGImageMap*) G__getstructoffset())->SetCursor((ECursor) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGImageMap*) G__getstructoffset())->SetCursor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->RegionClicked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->DoubleClicked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->DoubleClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->OnMouseOver((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->OnMouseOut((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGImageMap::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGImageMap::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGImageMap::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGImageMap::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGImageMap*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGImageMap::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGImageMap::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGImageMap::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_350_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGImageMap::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGImageMap G__TTGImageMap;
static int G__G__Gui2_350_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGImageMap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGImageMap*) (soff+(sizeof(TGImageMap)*i)))->~G__TTGImageMap();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGImageMap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGImageMap*) (soff))->~G__TTGImageMap();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGApplication */
static int G__G__Gui2_356_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGApplication* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGApplication(
(const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (char**) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGApplication(
(const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (char**) G__int(libp->para[2]), (void*) 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 TGApplication(
(const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (char**) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGApplication(
(const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (char**) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGApplication(
(const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (char**) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGApplication(
(const char*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (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__Gui2LN_TGApplication));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGApplication::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGApplication::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGApplication::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGApplication::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGApplication*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGApplication::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGApplication::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGApplication::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_356_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGApplication::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGApplication G__TTGApplication;
static int G__G__Gui2_356_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[] (TGApplication*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGApplication*) (soff+(sizeof(TGApplication)*i)))->~G__TTGApplication();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGApplication*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGApplication*) (soff))->~G__TTGApplication();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGXYLayoutHints */
static int G__G__Gui2_357_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGXYLayoutHints* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGXYLayoutHints(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGXYLayoutHints(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGXYLayoutHints(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGXYLayoutHints(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGXYLayoutHints*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGXYLayoutHints*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGXYLayoutHints*) G__getstructoffset())->GetW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGXYLayoutHints*) G__getstructoffset())->GetH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGXYLayoutHints*) G__getstructoffset())->GetFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayoutHints*) G__getstructoffset())->SetX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayoutHints*) G__getstructoffset())->SetY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayoutHints*) G__getstructoffset())->SetW((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayoutHints*) G__getstructoffset())->SetH((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayoutHints*) G__getstructoffset())->SetFlag((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGXYLayoutHints::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGXYLayoutHints::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGXYLayoutHints::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGXYLayoutHints::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayoutHints*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGXYLayoutHints::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGXYLayoutHints::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGXYLayoutHints::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_357_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGXYLayoutHints::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Gui2_357_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGXYLayoutHints* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGXYLayoutHints(*(TGXYLayoutHints*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGXYLayoutHints G__TTGXYLayoutHints;
static int G__G__Gui2_357_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[] (TGXYLayoutHints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGXYLayoutHints*) (soff+(sizeof(TGXYLayoutHints)*i)))->~G__TTGXYLayoutHints();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGXYLayoutHints*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGXYLayoutHints*) (soff))->~G__TTGXYLayoutHints();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGXYLayout */
static int G__G__Gui2_359_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGXYLayout* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGXYLayout((TGCompositeFrame*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGXYLayout((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__Gui2LN_TGXYLayout));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayout*) G__getstructoffset())->NewSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGXYLayout::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGXYLayout::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGXYLayout::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGXYLayout::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGXYLayout*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGXYLayout::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGXYLayout::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGXYLayout::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_359_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGXYLayout::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGXYLayout G__TTGXYLayout;
static int G__G__Gui2_359_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[] (TGXYLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGXYLayout*) (soff+(sizeof(TGXYLayout)*i)))->~G__TTGXYLayout();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGXYLayout*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGXYLayout*) (soff))->~G__TTGXYLayout();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTripleVSlider */
static int G__G__Gui2_360_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTripleVSlider* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTripleVSlider(
(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])
, (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 TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTripleVSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleVSlider(
(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) TGTripleVSlider(
(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 TGTripleVSlider(
(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) TGTripleVSlider(
(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 TGTripleVSlider((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTripleVSlider((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 TGTripleVSlider((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTripleVSlider((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTripleVSlider[n];
       } else {
         p = new((void*) gvp) TGTripleVSlider[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTripleVSlider;
       } else {
         p = new((void*) gvp) TGTripleVSlider;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleVSlider*) G__getstructoffset())->PointerPositionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleVSlider*) G__getstructoffset())->DrawPointer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGTripleVSlider*) G__getstructoffset())->GetPointerPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTripleVSlider*) G__getstructoffset())->SetConstrained((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTripleVSlider*) G__getstructoffset())->SetConstrained();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleVSlider*) G__getstructoffset())->SetPointerPosition((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTripleVSlider*) G__getstructoffset())->SetRelative((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTripleVSlider*) G__getstructoffset())->SetRelative();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTripleVSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTripleVSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTripleVSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTripleVSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleVSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTripleVSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTripleVSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTripleVSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_360_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTripleVSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTripleVSlider G__TTGTripleVSlider;
static int G__G__Gui2_360_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[] (TGTripleVSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTripleVSlider*) (soff+(sizeof(TGTripleVSlider)*i)))->~G__TTGTripleVSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTripleVSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTripleVSlider*) (soff))->~G__TTGTripleVSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGTripleHSlider */
static int G__G__Gui2_361_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGTripleHSlider* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGTripleHSlider(
(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])
, (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 TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGTripleHSlider(
(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])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGTripleHSlider(
(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) TGTripleHSlider(
(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 TGTripleHSlider(
(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) TGTripleHSlider(
(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 TGTripleHSlider((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGTripleHSlider((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 TGTripleHSlider((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGTripleHSlider((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTripleHSlider[n];
       } else {
         p = new((void*) gvp) TGTripleHSlider[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGTripleHSlider;
       } else {
         p = new((void*) gvp) TGTripleHSlider;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleHSlider*) G__getstructoffset())->PointerPositionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleHSlider*) G__getstructoffset())->DrawPointer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGTripleHSlider*) G__getstructoffset())->GetPointerPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTripleHSlider*) G__getstructoffset())->SetConstrained((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTripleHSlider*) G__getstructoffset())->SetConstrained();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleHSlider*) G__getstructoffset())->SetPointerPosition((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGTripleHSlider*) G__getstructoffset())->SetRelative((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGTripleHSlider*) G__getstructoffset())->SetRelative();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGTripleHSlider::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTripleHSlider::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGTripleHSlider::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGTripleHSlider::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGTripleHSlider*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTripleHSlider::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTripleHSlider::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGTripleHSlider::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Gui2_361_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGTripleHSlider::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGTripleHSlider G__TTGTripleHSlider;
static int G__G__Gui2_361_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[] (TGTripleHSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGTripleHSlider*) (soff+(sizeof(TGTripleHSlider)*i)))->~G__TTGTripleHSlider();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGTripleHSlider*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGTripleHSlider*) (soff))->~G__TTGTripleHSlider();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TGResourcePool */

/* TGFontPool */

/* TGFont */

/* TGMimeTypes */

/* FontMetrics_t */

/* FontAttributes_t */

/* TGTextLayout */

/* TGVFileSplitter */

/* TGToolTip */

/* TGScrollBarElement */

/* TGScrollBar */

/* TGHScrollBar */

/* TGVScrollBar */

/* TGViewPort */

/* TGCanvas */

/* TGListView */

/* TGContainer */

/* TGListBox */

/* TGLBEntry */

/* TGTextLBEntry */

/* TGLineLBEntry */

/* TGIconLBEntry */

/* TGLBContainer */

/* TGComboBoxPopup */

/* TGComboBox */

/* TGLineStyleComboBox */

/* TGLineWidthComboBox */

/* TGFontTypeComboBox */

/* TGTabElement */

/* TGTab */

/* TGTabLayout */

/* TGSlider */

/* TGVSlider */

/* TGHSlider */

/* TGSplitter */

/* TGVSplitter */

/* TGHSplitter */

/* TGLVContainer */

/* TGLVEntry */

/* TGFileContainer */

/* TGFileItem */

/* TGFSComboBox */

/* TGFileInfo */

/* TGFileDialog */

/* TGStatusBar */

/* ToolBarData_t */

/* TGToolBar */

/* TGListTreeItem */

/* TGListTree */

/* TGListTreeItemStd */

/* TGTextLine */

/* TGText */

/* TGViewFrame */

/* TGView */

/* TGTextView */

/* TGSearchType */

/* TGTextEdit */

/* TGSearchDialog */

/* TGPrintDialog */

/* TGGotoDialog */

/* TGDoubleSlider */

/* TGDoubleVSlider */

/* TGDoubleHSlider */

/* TGTreeLBEntry */

/* TGRegion */

/* TGRegionWithId */

/* TGImageMap */

/* TGApplication */

/* TGXYLayoutHints */

/* TGXYLayout */

/* TGTripleVSlider */

/* TGTripleHSlider */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Gui2 {
 public:
  G__Sizep2memfuncG__Gui2(): p(&G__Sizep2memfuncG__Gui2::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Gui2::*p)();
};

size_t G__get_sizep2memfuncG__Gui2()
{
  G__Sizep2memfuncG__Gui2 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__Gui2() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool))) {
     TGResourcePool *G__Lderived;
     G__Lderived=(TGResourcePool*)0x1000;
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool))) {
     TGFontPool *G__Lderived;
     G__Lderived=(TGFontPool*)0x1000;
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFont))) {
     TGFont *G__Lderived;
     G__Lderived=(TGFont*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFont),G__get_linked_tagnum(&G__G__Gui2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFont),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFont),G__get_linked_tagnum(&G__G__Gui2LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes))) {
     TGMimeTypes *G__Lderived;
     G__Lderived=(TGMimeTypes*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout))) {
     TGTextLayout *G__Lderived;
     G__Lderived=(TGTextLayout*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter))) {
     TGVFileSplitter *G__Lderived;
     G__Lderived=(TGVFileSplitter*)0x1000;
     {
       TGVSplitter *G__Lpbase=(TGVSplitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGSplitter *G__Lpbase=(TGSplitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip))) {
     TGToolTip *G__Lderived;
     G__Lderived=(TGToolTip*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement))) {
     TGScrollBarElement *G__Lderived;
     G__Lderived=(TGScrollBarElement*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar))) {
     TGScrollBar *G__Lderived;
     G__Lderived=(TGScrollBar*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar))) {
     TGHScrollBar *G__Lderived;
     G__Lderived=(TGHScrollBar*)0x1000;
     {
       TGScrollBar *G__Lpbase=(TGScrollBar*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar))) {
     TGVScrollBar *G__Lderived;
     G__Lderived=(TGVScrollBar*)0x1000;
     {
       TGScrollBar *G__Lpbase=(TGScrollBar*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort))) {
     TGViewPort *G__Lderived;
     G__Lderived=(TGViewPort*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas))) {
     TGCanvas *G__Lderived;
     G__Lderived=(TGCanvas*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGListView))) {
     TGListView *G__Lderived;
     G__Lderived=(TGListView*)0x1000;
     {
       TGCanvas *G__Lpbase=(TGCanvas*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView),G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer))) {
     TGContainer *G__Lderived;
     G__Lderived=(TGContainer*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox))) {
     TGListBox *G__Lderived;
     G__Lderived=(TGListBox*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry))) {
     TGLBEntry *G__Lderived;
     G__Lderived=(TGLBEntry*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry))) {
     TGTextLBEntry *G__Lderived;
     G__Lderived=(TGTextLBEntry*)0x1000;
     {
       TGLBEntry *G__Lpbase=(TGLBEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry))) {
     TGLineLBEntry *G__Lderived;
     G__Lderived=(TGLineLBEntry*)0x1000;
     {
       TGTextLBEntry *G__Lpbase=(TGTextLBEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLBEntry *G__Lpbase=(TGLBEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry))) {
     TGIconLBEntry *G__Lderived;
     G__Lderived=(TGIconLBEntry*)0x1000;
     {
       TGTextLBEntry *G__Lpbase=(TGTextLBEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLBEntry *G__Lpbase=(TGLBEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer))) {
     TGLBContainer *G__Lderived;
     G__Lderived=(TGLBContainer*)0x1000;
     {
       TGContainer *G__Lpbase=(TGContainer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup))) {
     TGComboBoxPopup *G__Lderived;
     G__Lderived=(TGComboBoxPopup*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox))) {
     TGComboBox *G__Lderived;
     G__Lderived=(TGComboBox*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox))) {
     TGLineStyleComboBox *G__Lderived;
     G__Lderived=(TGLineStyleComboBox*)0x1000;
     {
       TGComboBox *G__Lpbase=(TGComboBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox))) {
     TGLineWidthComboBox *G__Lderived;
     G__Lderived=(TGLineWidthComboBox*)0x1000;
     {
       TGComboBox *G__Lpbase=(TGComboBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox))) {
     TGFontTypeComboBox *G__Lderived;
     G__Lderived=(TGFontTypeComboBox*)0x1000;
     {
       TGComboBox *G__Lpbase=(TGComboBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement))) {
     TGTabElement *G__Lderived;
     G__Lderived=(TGTabElement*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTab))) {
     TGTab *G__Lderived;
     G__Lderived=(TGTab*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout))) {
     TGTabLayout *G__Lderived;
     G__Lderived=(TGTabLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout),G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider))) {
     TGSlider *G__Lderived;
     G__Lderived=(TGSlider*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider))) {
     TGVSlider *G__Lderived;
     G__Lderived=(TGVSlider*)0x1000;
     {
       TGSlider *G__Lpbase=(TGSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider))) {
     TGHSlider *G__Lderived;
     G__Lderived=(TGHSlider*)0x1000;
     {
       TGSlider *G__Lpbase=(TGSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGSlider),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter))) {
     TGSplitter *G__Lderived;
     G__Lderived=(TGSplitter*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter))) {
     TGVSplitter *G__Lderived;
     G__Lderived=(TGVSplitter*)0x1000;
     {
       TGSplitter *G__Lpbase=(TGSplitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter))) {
     TGHSplitter *G__Lderived;
     G__Lderived=(TGHSplitter*)0x1000;
     {
       TGSplitter *G__Lpbase=(TGSplitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer))) {
     TGLVContainer *G__Lderived;
     G__Lderived=(TGLVContainer*)0x1000;
     {
       TGContainer *G__Lpbase=(TGContainer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry))) {
     TGLVEntry *G__Lderived;
     G__Lderived=(TGLVEntry*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer))) {
     TGFileContainer *G__Lderived;
     G__Lderived=(TGFileContainer*)0x1000;
     {
       TGLVContainer *G__Lpbase=(TGLVContainer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGContainer *G__Lpbase=(TGContainer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem))) {
     TGFileItem *G__Lderived;
     G__Lderived=(TGFileItem*)0x1000;
     {
       TGLVEntry *G__Lpbase=(TGLVEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem),G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox))) {
     TGFSComboBox *G__Lderived;
     G__Lderived=(TGFSComboBox*)0x1000;
     {
       TGComboBox *G__Lpbase=(TGComboBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog))) {
     TGFileDialog *G__Lderived;
     G__Lderived=(TGFileDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar))) {
     TGStatusBar *G__Lderived;
     G__Lderived=(TGStatusBar*)0x1000;
     {
       TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar))) {
     TGToolBar *G__Lderived;
     G__Lderived=(TGToolBar*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree))) {
     TGListTree *G__Lderived;
     G__Lderived=(TGListTree*)0x1000;
     {
       TGContainer *G__Lpbase=(TGContainer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TGContainer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd))) {
     TGListTreeItemStd *G__Lderived;
     G__Lderived=(TGListTreeItemStd*)0x1000;
     {
       TGListTreeItem *G__Lpbase=(TGListTreeItem*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd),G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame))) {
     TGViewFrame *G__Lderived;
     G__Lderived=(TGViewFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGView))) {
     TGView *G__Lderived;
     G__Lderived=(TGView*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView))) {
     TGTextView *G__Lderived;
     G__Lderived=(TGTextView*)0x1000;
     {
       TGView *G__Lpbase=(TGView*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TGView),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit))) {
     TGTextEdit *G__Lderived;
     G__Lderived=(TGTextEdit*)0x1000;
     {
       TGTextView *G__Lpbase=(TGTextView*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGTextView),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGView *G__Lpbase=(TGView*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGView),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog))) {
     TGSearchDialog *G__Lderived;
     G__Lderived=(TGSearchDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog))) {
     TGPrintDialog *G__Lderived;
     G__Lderived=(TGPrintDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog))) {
     TGGotoDialog *G__Lderived;
     G__Lderived=(TGGotoDialog*)0x1000;
     {
       TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider))) {
     TGDoubleSlider *G__Lderived;
     G__Lderived=(TGDoubleSlider*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider))) {
     TGDoubleVSlider *G__Lderived;
     G__Lderived=(TGDoubleVSlider*)0x1000;
     {
       TGDoubleSlider *G__Lpbase=(TGDoubleSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider))) {
     TGDoubleHSlider *G__Lderived;
     G__Lderived=(TGDoubleHSlider*)0x1000;
     {
       TGDoubleSlider *G__Lpbase=(TGDoubleSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry))) {
     TGTreeLBEntry *G__Lderived;
     G__Lderived=(TGTreeLBEntry*)0x1000;
     {
       TGLBEntry *G__Lpbase=(TGLBEntry*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGRegion))) {
     TGRegion *G__Lderived;
     G__Lderived=(TGRegion*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegion),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId))) {
     TGRegionWithId *G__Lderived;
     G__Lderived=(TGRegionWithId*)0x1000;
     {
       TGRegion *G__Lpbase=(TGRegion*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId),G__get_linked_tagnum(&G__G__Gui2LN_TGRegion),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap))) {
     TGImageMap *G__Lderived;
     G__Lderived=(TGImageMap*)0x1000;
     {
       TGPictureButton *G__Lpbase=(TGPictureButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TGPictureButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGApplication))) {
     TGApplication *G__Lderived;
     G__Lderived=(TGApplication*)0x1000;
     {
       TApplication *G__Lpbase=(TApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGApplication),G__get_linked_tagnum(&G__G__Gui2LN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGApplication),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGApplication),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints))) {
     TGXYLayoutHints *G__Lderived;
     G__Lderived=(TGXYLayoutHints*)0x1000;
     {
       TGLayoutHints *G__Lpbase=(TGLayoutHints*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints),G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TRefCnt *G__Lpbase=(TRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints),G__get_linked_tagnum(&G__G__Gui2LN_TRefCnt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout))) {
     TGXYLayout *G__Lderived;
     G__Lderived=(TGXYLayout*)0x1000;
     {
       TGLayoutManager *G__Lpbase=(TGLayoutManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout),G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider))) {
     TGTripleVSlider *G__Lderived;
     G__Lderived=(TGTripleVSlider*)0x1000;
     {
       TGDoubleVSlider *G__Lpbase=(TGDoubleVSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGDoubleSlider *G__Lpbase=(TGDoubleSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider))) {
     TGTripleHSlider *G__Lderived;
     G__Lderived=(TGTripleHSlider*)0x1000;
     {
       TGDoubleHSlider *G__Lpbase=(TGDoubleHSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGDoubleSlider *G__Lpbase=(TGDoubleSlider*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider),G__get_linked_tagnum(&G__G__Gui2LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Gui2() {

   /* 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("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Gui2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Gui2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui2LN_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("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("Cursor_t",107,-1,0,-1);
   G__setnewtype(-1,"Cursor 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("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2LN_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__Gui2LN_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__Gui2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__G__Gui2LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Gui2LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui2LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Gui2LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Gui2LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TGResourcePool */
static void G__setup_memvarTGResourcePool(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool));
   { TGResourcePool *p; p=(TGResourcePool*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fBackColor=",0,"default background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fForeColor=",0,"default foreground color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fHilite=",0,"default hilite color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fShadow=",0,"default shadow color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fSelBackColor=",0,"default selection background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fSelForeColor=",0,"default selection foreground color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fDocBackColor=",0,"default document background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fDocForeColor=",0,"default document foreground color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fTipBackColor=",0,"default tip background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fTipForeColor=",0,"default tip foreground color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fWhite=",0,"white color index");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,4,"fBlack=",0,"black color index");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool),-1,-1,4,"fFontPool=",0,"font pool manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fDefaultFont=",0,"default font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fMenuFont=",0,"menu font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fMenuHiFont=",0,"menu highlight font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fDocFixedFont=",0,"document fixed font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fDocPropFont=",0,"document proportional font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fIconFont=",0,"icon font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,4,"fStatusFont=",0,"status bar font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPicturePool),-1,-1,4,"fPicturePool=",0,"picture pool manager");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,4,"fDefaultBackPicture=",0,"default background picture");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,4,"fDefaultDocBackPicture=",0,"default document background picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGCPool),-1,-1,4,"fGCPool=",0,"graphics drawing context pool manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fWhiteGC=",0,"white gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fBlackGC=",0,"black gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fFrameGC=",0,"frame gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fBckgndGC=",0,"frame background gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fHiliteGC=",0,"frame hilite gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fShadowGC=",0,"frame shadow gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fFocusGC=",0,"frame focus gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fDocGC=",0,"document gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fDocbgndGC=",0,"document background gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fSelGC=",0,"selection gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fSelbgndGC=",0,"selection background gc");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,4,"fTipGC=",0,"tooltip gc");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,4,"fCheckered=",0,"checkered pixmap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,4,"fCheckeredBitmap=",0,"checkered bitmap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,4,"fDefaultCursor=",0,"default cursor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,4,"fGrabCursor=",0,"grab cursor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,4,"fTextCursor=",0,"text cursor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Cursor_t"),-1,4,"fWaitCursor=",0,"wait cursor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Colormap_t"),-1,4,"fDefaultColormap=",0,"default colormap");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Atom_t"),-1,4,"fClipboardAtom=",0,"handle to clipboard");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes),-1,-1,4,"fMimeTypeList=",0,"list of mime types");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFontPool */
static void G__setup_memvarTGFontPool(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool));
   { TGFontPool *p; p=(TGFontPool*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_THashTable),-1,-1,4,"fList=",0,"TGFont objects pool");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_THashTable),-1,-1,4,"fUidTable=",0,"Hash table for some used string values like family names, etc.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_THashTable),-1,-1,4,"fNamedTable=",0,"Map a name to a set of attributes for a font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFont */
static void G__setup_memvarTGFont(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFont));
   { TGFont *p; p=(TGFont*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,4,"fFontStruct=",0,"Low level graphics fontstruct");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontH_t"),-1,4,"fFontH=",0,"Font handle (derived from fontstruct)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t),-1,-1,4,"fFM=",0,"Cached font metrics");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t),-1,-1,4,"fFA=",0,"Actual font attributes obtained when the font was created");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TObjString),-1,-1,4,"fNamedHash=",0,"Pointer to the named object TGFont was based on");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTabWidth=",0,"Width of tabs in this font (pixels).");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fUnderlinePos=",0,"Offset from baseline to origin of underline bar");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fUnderlineHeight=",0,"Height of underline bar (used for drawing");
   G__memvar_setup((void*)0,99,0,0,-1,-1,-1,4,"fTypes[256]=",0,"Array giving types of all characters in");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWidths[256]=",0,"Array giving widths of all possible characters in the font.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBarHeight=",0,"Height of underline or overstrike bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGMimeTypes */
static void G__setup_memvarTGMimeTypes(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes));
   { TGMimeTypes *p; p=(TGMimeTypes*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGClient),-1,-1,2,"fClient=",0,"client to which mime types belong (display server)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,2,"fFilename=",0,"file name of mime type file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,"true if file has changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TOrdCollection),-1,-1,2,"fList=",0,"list of mime types");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* FontMetrics_t */
static void G__setup_memvarFontMetrics_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t));
   { FontMetrics_t *p; p=(FontMetrics_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fAscent)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fAscent=",0,"from baseline to top of font");
   G__memvar_setup((void*)((long)(&p->fDescent)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fDescent=",0,"from baseline to bottom of font");
   G__memvar_setup((void*)((long)(&p->fLinespace)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLinespace=",0,"the sum of the ascent and descent");
   G__memvar_setup((void*)((long)(&p->fMaxWidth)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMaxWidth=",0,"width of widest character in font");
   G__memvar_setup((void*)((long)(&p->fFixed)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFixed=",0,"true if monospace, false otherwise");
   }
   G__tag_memvar_reset();
}


   /* FontAttributes_t */
static void G__setup_memvarFontAttributes_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t));
   { FontAttributes_t *p; p=(FontAttributes_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fFamily)-(long)(p)),67,0,1,-1,-1,-1,1,"fFamily=",0,"Font family. The most important field.");
   G__memvar_setup((void*)((long)(&p->fPointsize)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPointsize=",0,"Pointsize of font, 0 for default size, or negative number meaning pixel size.");
   G__memvar_setup((void*)((long)(&p->fWeight)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fWeight=",0,"Weight flag; see below for def'n.");
   G__memvar_setup((void*)((long)(&p->fSlant)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSlant=",0,"Slant flag; see below for def'n.");
   G__memvar_setup((void*)((long)(&p->fUnderline)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fUnderline=",0,"Non-zero for underline font.");
   G__memvar_setup((void*)((long)(&p->fOverstrike)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fOverstrike=",0,"Non-zero for overstrike font.");
   }
   G__tag_memvar_reset();
}


   /* TGTextLayout */
static void G__setup_memvarTGTextLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout));
   { TGTextLayout *p; p=(TGTextLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-1,2,"fFont=",0,"The font used when laying out the text.");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-1,2,"fString=",0,"The string that was layed out.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWidth=",0,"The maximum width of all lines in the text layout.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumChunks=",0,"Number of chunks actually used in following array.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_LayoutChunk_t),-1,-1,2,"fChunks=",0,"Array of chunks. The actual size will be maxChunks.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVFileSplitter */
static void G__setup_memvarTGVFileSplitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter));
   { TGVFileSplitter *p; p=(TGVFileSplitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGToolTip */
static void G__setup_memvarTGToolTip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip));
   { TGToolTip *p; p=(TGToolTip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLabel),-1,-1,4,"fLabel=",0,"help text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,4,"fL1=",0,"layout used to place text in frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TTimer),-1,-1,4,"fDelay=",0,"popup delay timer");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),-1,-1,4,"fWindow=",0,"frame to which tool tip is associated");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TVirtualPad),-1,-1,4,"fPad=",0,"pad to which tooltip is associated");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TBox),-1,-1,4,"fBox=",0,"box in pad to which tooltip is associated");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fX=",0,"X position in fWindow where to popup");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fY=",0,"Y position in fWindow where to popup");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGScrollBarElement */
static void G__setup_memvarTGScrollBarElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement));
   { TGScrollBarElement *p; p=(TGScrollBarElement*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fState=",0,"state of scrollbar element (button up or down)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPic=",0,"picture in scrollbar element");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPicN=",0,"picture for normal state of scrollbar element");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPicD=",0,"picture for disabled state of scrollbar element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGScrollBar */
static void G__setup_memvarTGScrollBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar));
   { TGScrollBar *p; p=(TGScrollBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX0=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY0=",0,"current slider position in pixels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXp=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYp=",0,"previous slider position in pixels");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDragging=",0,"in dragging mode?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGrabPointer=",0,"grab pointer when dragging");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRange=",0,"logical upper range of scrollbar");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPsize=",0,"logical page size of scrollbar");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPos=",0,"logical current position");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSliderSize=",0,"logical slider size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSliderRange=",0,"logical slider range");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSmallInc=",0,"Small Increment in the sliding algorithm");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),-1,-1,2,"fHead=",0,"head button of scrollbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),-1,-1,2,"fTail=",0,"tail button of scrollbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),-1,-1,2,"fSlider=",0,"slider");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fHeadPic=",0,"picture in head (up or left arrow)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fTailPic=",0,"picture in tail (down or right arrow)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TTimer),-1,-1,2,"fRepeat=",0,"repeat rate timer (when mouse stays pressed)");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-1,2,"fSubw=",0,"sub window in which mouse is pressed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAccelerated=",0,"kFALSE - normal, kTRUE - accelerated");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-2,2,"fgBckgndPixmap=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgScrollBarWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHScrollBar */
static void G__setup_memvarTGHScrollBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar));
   { TGHScrollBar *p; p=(TGHScrollBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVScrollBar */
static void G__setup_memvarTGVScrollBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar));
   { TGVScrollBar *p; p=(TGVScrollBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGViewPort */
static void G__setup_memvarTGViewPort(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort));
   { TGViewPort *p; p=(TGViewPort*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX0=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY0=",0,"position of container frame in viewport");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),-1,-1,2,"fContainer=",0,"container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGCanvas */
static void G__setup_memvarTGCanvas(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas));
   { TGCanvas *p; p=(TGCanvas*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),-1,-1,2,"fVport=",0,"viewport through which we look at contents");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),-1,-1,2,"fHScrollbar=",0,"horizontal scrollbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),-1,-1,2,"fVScrollbar=",0,"vertical scrollbar");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScrolling=",0,"flag which scrolling modes are allowed");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGCanvascLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCanvasNoScroll=%lldLL",(long long)TGCanvas::kCanvasNoScroll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGCanvascLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCanvasScrollHorizontal=%lldLL",(long long)TGCanvas::kCanvasScrollHorizontal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGCanvascLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCanvasScrollVertical=%lldLL",(long long)TGCanvas::kCanvasScrollVertical).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGCanvascLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCanvasScrollBoth=%lldLL",(long long)TGCanvas::kCanvasScrollBoth).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListView */
static void G__setup_memvarTGListView(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView));
   { TGListView *p; p=(TGListView*)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,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColumns=",0,"column width");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fJmode=",0,"column text alignment");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,2,"fViewMode=",0,"view mode if list view widget");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGDimension),-1,-1,2,"fMaxSize=",0,"maximum item size");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextButton),-1,-1,2,"fColHeader=",0,"column headers for in detailed mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,2,"fColNames=",0,"column titles for in detailed mode");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter),-1,-1,2,"fSplitHeader=",0,"column splitters");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"drawing graphics context");
   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,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGHeaderFrame),-1,-1,2,"fHeader=",0,"frame used as container for column headers");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fJustChanged=",0,"Indicate whether the view mode was just changed to Detail");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMinColumnSize=",0,"Minimun column size");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGContainer */
static void G__setup_memvarTGContainer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer));
   { TGContainer *p; p=(TGContainer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),-1,-1,2,"fViewPort=",0,"container viewport");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas),-1,-1,2,"fCanvas=",0,"pointer to canvas");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGWindow),-1,-1,2,"fMsgWindow=",0,"window handling container messages");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFrameElement),-1,-1,2,"fLastActiveEl=",0,"last active item");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXp=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYp=",0,"previous pointer position");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fX0=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY0=",0,"corner of rubber band box");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXf=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYf=",0,"other corner of rubber band box");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDragging=",0,"true if in dragging mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTotal=",0,"total items");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSelected=",0,"number of selected items");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TTimer),-1,-1,2,"fScrollTimer=",0,"autoscroll timer");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOnMouseOver=",0,"kTRUE when mouse pointer is over entry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLastDir=",0,"direction of last search");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLastCase=",0,"case sensetivity of last search");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLastSubstring=",0,"substring search option of last search");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,2,"fLastName=",0,"the name of object of last search");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TTimer),-1,-1,2,"fKeyTimer=",0,"keyboard timer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,2,"fKeyInput=",0,"keyboard input (buffer)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fKeyTimerActive=",0,"kTRUE - keyboard timer is active");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fScrolling=",0,"kTRUE - when scrolling is ON");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXDND=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYDND=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBdown=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGRectangle),-1,-1,2,"fExposedRegion=",0,"exposed area");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgLineGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListBox */
static void G__setup_memvarTGListBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox));
   { TGListBox *p; p=(TGListBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fItemVsize=",0,"maximum height of single entry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIntegralHeight=",0,"true if height should be multiple of fItemVsize");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer),-1,-1,2,"fLbc=",0,"listbox container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort),-1,-1,2,"fVport=",0,"listbox viewport (see TGCanvas.h)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),-1,-1,2,"fVScrollbar=",0,"vertical scrollbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLBEntry */
static void G__setup_memvarTGLBEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry));
   { TGLBEntry *p; p=(TGLBEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEntryId=",0,"message id of listbox entry");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBkcolor=",0,"entry background color");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"true if entry is active");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextLBEntry */
static void G__setup_memvarTGTextLBEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry));
   { TGTextLBEntry *p; p=(TGTextLBEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGString),-1,-1,2,"fText=",0,"entry text string");
   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,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTextChanged=",0,"true if text has been changed");
   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 string");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLineLBEntry */
static void G__setup_memvarTGLineLBEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry));
   { TGLineLBEntry *p; p=(TGLineLBEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLineWidth=",0,"line width");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fLineStyle=",0,"line style");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLineLength=",0,"line lenght");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,2,"fLineGC=",0,"line graphics context");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGIconLBEntry */
static void G__setup_memvarTGIconLBEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry));
   { TGIconLBEntry *p; p=(TGIconLBEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPicture=",0,"icon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLBContainer */
static void G__setup_memvarTGLBContainer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer));
   { TGLBContainer *p; p=(TGLBContainer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),-1,-1,2,"fLastActive=",0,"last active listbox entry in single selection listbox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),-1,-1,2,"fListBox=",0,"list box which contains this container");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMultiSelect=",0,"true if multi selection is switched on");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fChangeStatus=",0,"defines the changes (select or unselect) while the mouse");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGComboBoxPopup */
static void G__setup_memvarTGComboBoxPopup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup));
   { TGComboBoxPopup *p; p=(TGComboBoxPopup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),-1,-1,2,"fListBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),-1,-1,2,"fSelected=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGComboBox */
static void G__setup_memvarTGComboBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox));
   { TGComboBox *p; p=(TGComboBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry),-1,-1,2,"fSelEntry=",0,"selected item frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry),-1,-1,2,"fTextEntry=",0,"text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement),-1,-1,2,"fDDButton=",0,"button controlling drop down of popup");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup),-1,-1,2,"fComboFrame=",0,"popup containing a listbox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListBox),-1,-1,2,"fListBox=",0,"the listbox with text items");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fBpic=",0,"down arrow picture used in fDDButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fLhs=",0,"layout hints for selected item frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fLhb=",0,"layout hints for fDDButton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fLhdd=",0,"layout hints for fListBox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLineStyleComboBox */
static void G__setup_memvarTGLineStyleComboBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox));
   { TGLineStyleComboBox *p; p=(TGLineStyleComboBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLineWidthComboBox */
static void G__setup_memvarTGLineWidthComboBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox));
   { TGLineWidthComboBox *p; p=(TGLineWidthComboBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFontTypeComboBox */
static void G__setup_memvarTGFontTypeComboBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox));
   { TGFontTypeComboBox *p; p=(TGFontTypeComboBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFonts[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTabElement */
static void G__setup_memvarTGTabElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement));
   { TGTabElement *p; p=(TGTabElement*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGString),-1,-1,2,"fText=",0,"text on tab");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fClosePic=",0,"\"close tab\" icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fClosePicD=",0,"\"close tab\" icon (disabled)");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"graphics context for drawing tab");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"font used for tab");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTWidth=",0,"width of tab text");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTHeight=",0,"height of tab text");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnabled=",0,"enabled or disabled");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowClose=",0,"show or hide close icon");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"true if active (in front)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTab */
static void G__setup_memvarTGTab(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab));
   { TGTab *p; p=(TGTab*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrent=",0,"index of current tab");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTabh=",0,"tab height");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fContainer=",0,"main container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,2,"fRemoved=",0,"list of removed tabs");
   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("GContext_t"),-1,2,"fNormGC=",0,"drawing context");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTabLayout */
static void G__setup_memvarTGTabLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout));
   { TGTabLayout *p; p=(TGTabLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTab),-1,-1,2,"fMain=",0,"container frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSlider */
static void G__setup_memvarTGSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider));
   { TGSlider *p; p=(TGSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPos=",0,"logical position between fVmin and fVmax");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRelPos=",0,"slider position in pixel coordinates");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVmin=",0,"logical lower limit of slider");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVmax=",0,"logical upper limit of slider");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"slider type bits");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScale=",0,"tick mark scale");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDragging=",0,"true if in dragging mode");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSliderPic=",0,"picture to draw slider");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fDisabledPic=",0,"picture to draw disabled slider");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVSlider */
static void G__setup_memvarTGVSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider));
   { TGVSlider *p; p=(TGVSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYp=",0,"vertical slider y position in pixel coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHSlider */
static void G__setup_memvarTGHSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider));
   { TGHSlider *p; p=(TGHSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXp=",0,"horizontal slider x position in pixel coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSplitter */
static void G__setup_memvarTGSplitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter));
   { TGSplitter *p; p=(TGSplitter*)0x1000; if (p) { }
   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,"fDragging=",0,"true if in dragging mode");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fExternalHandler=",0,"true when splitter movement is handled externally");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSplitterPic=",0,"picture to draw splitter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGVSplitter */
static void G__setup_memvarTGVSplitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter));
   { TGVSplitter *p; p=(TGVSplitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStartX=",0,"x position when dragging starts");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFrameWidth=",0,"width of frame to be resized");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFrameHeight=",0,"height of frame to be resized");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMin=",0,"min x position frame can be resized to");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMax=",0,"max x position frame can be resized to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),-1,-1,2,"fFrame=",0,"frame that should be resized");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLeft=",0,"true if frame is on the left of splitter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGHSplitter */
static void G__setup_memvarTGHSplitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter));
   { TGHSplitter *p; p=(TGHSplitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStartY=",0,"y position when dragging starts");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFrameWidth=",0,"width of frame to be resized");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFrameHeight=",0,"height of frame to be resized");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMin=",0,"min y position frame can be resized to");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMax=",0,"max y position frame can be resized to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFrame),-1,-1,2,"fFrame=",0,"frame that should be resized");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAbove=",0,"true if frame is above the splitter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLVContainer */
static void G__setup_memvarTGLVContainer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer));
   { TGLVContainer *p; p=(TGLVContainer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fItemLayout=",0,"item layout hints");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,2,"fViewMode=",0,"list view viewing mode");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCpos=",0,"position of sub names");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fJmode=",0,"alignment of sub names");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMultiSelect=",0,"true = multiple file selection");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListView),-1,-1,2,"fListView=",0,"listview which contains this container");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry),-1,-1,2,"fLastActive=",0,"last active item");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLVEntry */
static void G__setup_memvarTGLVEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry));
   { TGLVEntry *p; p=(TGLVEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGString),-1,-1,2,"fItemName=",0,"name of item");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Gui2LN_TGString),-1,-1,2,"fSubnames=",0,"sub names of item (details)");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCpos=",0,"position of sub names");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fJmode=",0,"alignment for sub names");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCtw=",0,"width of sub names");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTWidth=",0,"width of name");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTHeight=",0,"height of name");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"true if item is active");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChecked=",0,"true if item is checked");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,2,"fViewMode=",0,"list view viewing mode");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fBigPic=",0,"big icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSmallPic=",0,"small icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fCurrent=",0,"current icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fCheckMark=",0,"checkmark");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGSelectedPicture),-1,-1,2,"fSelPic=",0,"selected icon");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"drawing graphics context");
   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,89,0,0,-1,-1,-1,2,"fUserData=",0,"pointer to user data structure");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFileContainer */
static void G__setup_memvarTGFileContainer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer));
   { TGFileContainer *p; p=(TGFileContainer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,2,"fSortType=",0,"sorting mode of contents");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TRegexp),-1,-1,2,"fFilter=",0,"file filter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TViewUpdateTimer),-1,-1,2,"fRefresh=",0,"refresh timer");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fMtime=",0,"directory modification time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,2,"fDirectory=",0,"current directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,2,"fCleanups=",0,"list of pictures to cleanup");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fFolder_t=",0,"small folder icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fFolder_s=",0,"big folder icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fApp_t=",0,"small application icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fApp_s=",0,"big application icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fDoc_t=",0,"small document icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fDoc_s=",0,"big document icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSlink_t=",0,"small symbolic link icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSlink_s=",0,"big symbolic link icon");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCachePictures=",0,"kTRUE use caching");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDisplayStat=",0,"kFALSE to interrupt display directory");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFileItem */
static void G__setup_memvarTGFileItem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem));
   { TGFileItem *p; p=(TGFileItem*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fBlpic=",0,"big icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSlpic=",0,"small icon");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fLcurrent=",0,"current icon");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"file type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fUid=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fGid=",0,"file uid and gid");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsLink=",0,"true if symbolic link");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fModTime=",0,"modification time");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSize=",0,"file size");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TBufferFile),-1,-1,2,"fBuf=",0,"buffer used for Drag and Drop");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TDNDData),-1,-1,2,"fDNDData=",0,"Drag and Drop data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFSComboBox */
static void G__setup_memvarTGFSComboBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox));
   { TGFSComboBox *p; p=(TGFSComboBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGFileInfo */
static void G__setup_memvarTGFileInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo));
   { TGFileInfo *p; p=(TGFileInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fFilename)-(long)(p)),67,0,0,-1,-1,-1,1,"fFilename=",0,"selected file name");
   G__memvar_setup((void*)((long)(&p->fIniDir)-(long)(p)),67,0,0,-1,-1,-1,1,"fIniDir=",0,"on input: initial directory, on output: new directory");
   G__memvar_setup((void*)((long)(&p->fFileTypes)-(long)(p)),67,2,1,-1,-1,-1,1,"fFileTypes=",0,"file types used to filter selectable files");
   G__memvar_setup((void*)((long)(&p->fFileTypeIdx)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fFileTypeIdx=",0,"selected file type, index in fFileTypes");
   G__memvar_setup((void*)((long)(&p->fOverwrite)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fOverwrite=",0,"if true overwrite the file with existing name on save");
   G__memvar_setup((void*)((long)(&p->fMultipleSelection)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMultipleSelection=",0,"if true, allow multiple file selection");
   G__memvar_setup((void*)((long)(&p->fFileNamesList)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,1,"fFileNamesList=",0,"list of selected file names");
   }
   G__tag_memvar_reset();
}


   /* TGFileDialog */
static void G__setup_memvarTGFileDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog));
   { TGFileDialog *p; p=(TGFileDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextBuffer),-1,-1,2,"fTbfname=",0,"text buffer of file name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry),-1,-1,2,"fName=",0,"file name text entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),-1,-1,2,"fTypes=",0,"file type combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox),-1,-1,2,"fTreeLB=",0,"file system path combo box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPictureButton),-1,-1,2,"fCdup=",0,"top toolbar button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPictureButton),-1,-1,2,"fNewf=",0,"top toolbar button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPictureButton),-1,-1,2,"fList=",0,"top toolbar button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPictureButton),-1,-1,2,"fDetails=",0,"top toolbar button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCheckButton),-1,-1,2,"fCheckB=",0,"set on/off file overwriting for Open dialog");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPcdup=",0,"picture for fCdup");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPnewf=",0,"picture for fNewf");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPlist=",0,"picture for fList");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPdetails=",0,"picture for fDetails");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextButton),-1,-1,2,"fOk=",0,"ok button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextButton),-1,-1,2,"fCancel=",0,"cancel button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListView),-1,-1,2,"fFv=",0,"file list view");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer),-1,-1,2,"fFc=",0,"file list view container (containing the files)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo),-1,-1,2,"fFileInfo=",0,"file info passed to this dialog");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGStatusBar */
static void G__setup_memvarTGStatusBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar));
   { TGStatusBar *p; p=(TGStatusBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBarPart),-1,-1,2,"fStatusPart=",0,"frames containing statusbar text");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fParts=",0,"size of parts (in percent of total width)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpart=",0,"number of parts");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYt=",0,"y drawing position (depending on font)");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXt=",0,"x position for each part");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"f3DCorner=",0,"draw 3D corner (drawn by default)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ToolBarData_t */
static void G__setup_memvarToolBarData_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_ToolBarData_t));
   { ToolBarData_t *p; p=(ToolBarData_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fPixmap)-(long)(p)),67,0,1,-1,-1,-1,1,"fPixmap=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTipText)-(long)(p)),67,0,1,-1,-1,-1,1,"fTipText=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fStayDown)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fStayDown=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fId)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fId=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fButton)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,1,"fButton=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGToolBar */
static void G__setup_memvarTGToolBar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar));
   { TGToolBar *p; p=(TGToolBar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,2,"fPictures=",0,"list of pictures that should be freed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,2,"fTrash=",0,"list of buttons and layout hints to be deleted");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListTreeItem */
static void G__setup_memvarTGListTreeItem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem));
   { TGListTreeItem *p; p=(TGListTreeItem*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGClient),-1,-1,2,"fClient=",0,"pointer to TGClient");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fParent=",0,"pointer to parent");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fFirstchild=",0,"pointer to first child item");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fLastchild=",0,"pointer to last child item");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fPrevsibling=",0,"pointer to previous sibling");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fNextsibling=",0,"pointer to next sibling");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOpen=",0,"true if item is open");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDNDState=",0,"EDNDFlags");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fY=",0,"y position of item");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXtext=",0,"x position of item text");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYtext=",0,"y position of item text");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fHeight=",0,"item 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__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListTree */
static void G__setup_memvarTGListTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree));
   { TGListTree *p; p=(TGListTree*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLEColorMarkupMode),-1,-2,1,G__FastAllocString(2048).Format("kDefault=%lldLL",(long long)TGListTree::kDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLEColorMarkupMode),-1,-2,1,G__FastAllocString(2048).Format("kColorUnderline=%lldLL",(long long)TGListTree::kColorUnderline).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLEColorMarkupMode),-1,-2,1,G__FastAllocString(2048).Format("kColorBox=%lldLL",(long long)TGListTree::kColorBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLECheckMode),-1,-2,1,G__FastAllocString(2048).Format("kSimple=%lldLL",(long long)TGListTree::kSimple).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLECheckMode),-1,-2,1,G__FastAllocString(2048).Format("kRecursive=%lldLL",(long long)TGListTree::kRecursive).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fFirst=",0,"pointer to first item in list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fLast=",0,"pointer to last item in list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fSelected=",0,"pointer to selected item in list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fCurrent=",0,"pointer to current item in list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fBelowMouse=",0,"pointer to item below mouses cursor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHspacing=",0,"horizontal spacing between items");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVspacing=",0,"vertical spacing between items");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndent=",0,"number of pixels indentation");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMargin=",0,"number of pixels margin from left side");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fGrayPixel=",0,"gray draw color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fDrawGC=",0,"icon drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fLineGC=",0,"dashed line drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fHighlightGC=",0,"highlighted icon drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFont=",0,"font used to draw item text");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDefw=",0,"default list width");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDefh=",0,"default list height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fExposeTop=",0,"top y postion of visible region");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fExposeBottom=",0,"bottom y position of visible region");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),-1,-1,2,"fTip=",0,"tooltip shown when moving over list items");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem),-1,-1,2,"fTipItem=",0,"item for which tooltip is set");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TBufferFile),-1,-1,2,"fBuf=",0,"buffer used for Drag and Drop");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TDNDData),-1,-1,2,"fDNDData=",0,"Drag and Drop data");
   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__Gui2LN_TGListTreeItem),-1,-1,2,"fDropItem=",0,"item on which DND is over");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoTips=",0,"assume item->fUserData is TObject and use GetTitle() for tip text");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoCheckBoxPic=",0,"change check box picture if parent and children have diffrent state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDisableOpen=",0,"disable branch opening on double-clicks");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUserControlled=",0,"let user decides what is the behaviour on events");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEventHandled=",0,"flag used from user code to bypass standard event handling");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLastEventState=",0,"modifier state of the last keyboard event");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLEColorMarkupMode),-1,-1,2,"fColorMode=",0,"if/how to render item's main color");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLECheckMode),-1,-1,2,"fCheckMode=",0,"how to propagate check properties through the tree");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fColorGC=",0,"drawing context for main item color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgGrayPixel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDrawGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgLineGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgHighlightGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgColorGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-2,2,"fgOpenPic=",0,"icon for open item");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-2,2,"fgClosedPic=",0,"icon for closed item");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-2,2,"fgCheckedPic=",0,"icon for checked item");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-2,2,"fgUncheckedPic=",0,"icon for unchecked item");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGListTreeItemStd */
static void G__setup_memvarTGListTreeItemStd(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd));
   { TGListTreeItemStd *p; p=(TGListTreeItemStd*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fActive=",0,"true if item is active");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCheckBox=",0,"true if checkbox is visible");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fChecked=",0,"true if item is checked");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fOwnsData=",0,"true if user data has to be deleted");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,4,"fText=",0,"item text");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,4,"fTipText=",0,"tooltip text");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,4,"fOpenPic=",0,"icon for open state");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,4,"fClosedPic=",0,"icon for closed state");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,4,"fCheckedPic=",0,"icon for checked item");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,4,"fUncheckedPic=",0,"icon for unchecked item");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fUserData=",0,"pointer to user data structure");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHasColor=",0,"true if item has assigned color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fColor=",0,"item's color");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextLine */
static void G__setup_memvarTGTextLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine));
   { TGTextLine *p; p=(TGTextLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fString=",0,"line of text");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fLength=",0,"lenght of line");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine),-1,-1,2,"fPrev=",0,"previous line");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine),-1,-1,2,"fNext=",0,"next line");
   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__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGText */
static void G__setup_memvarTGText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGText));
   { TGText *p; p=(TGText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TString),-1,-1,2,"fFilename=",0,"name of opened file (\"\" if open buffer)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsSaved=",0,"false if text needs to be saved");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine),-1,-1,2,"fFirst=",0,"first line of text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine),-1,-1,2,"fCurrent=",0,"current line");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fCurrentRow=",0,"current row number");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fRowCount=",0,"number of rows");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fColCount=",0,"number of columns in current line");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fLongestLine=",0,"length of longest line");
   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__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGViewFrame */
static void G__setup_memvarTGViewFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame));
   { TGViewFrame *p; p=(TGViewFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGView),-1,-1,4,"fView=",0,"pointer back to the view");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGView */
static void G__setup_memvarTGView(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView));
   { TGView *p; p=(TGView*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGViewcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoHSB=%lldLL",(long long)TGView::kNoHSB).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGViewcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoVSB=%lldLL",(long long)TGView::kNoVSB).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGViewcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kHorizontal=%lldLL",(long long)TGView::kHorizontal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGViewcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kVertical=%lldLL",(long long)TGView::kVertical).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition),-1,-1,2,"fVisible=",0,"position of visible region");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition),-1,-1,2,"fMousePos=",0,"position of mouse");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition),-1,-1,2,"fScrollVal=",0,"scroll value");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGDimension),-1,-1,2,"fVirtualSize=",0,"the current virtual window size");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGRectangle),-1,-1,2,"fExposedRegion=",0,"exposed area   ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScrolling=",0,"scrolling direction");
   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,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fXMargin=",0,"x margin");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fYMargin=",0,"y margin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame),-1,-1,2,"fCanvas=",0,"frame containing the text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar),-1,-1,2,"fHsb=",0,"horizontal scrollbar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar),-1,-1,2,"fVsb=",0,"vertical scrollbar");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,2,"fWhiteGC=",0,"graphics context used for scrolling");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextView */
static void G__setup_memvarTGTextView(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView));
   { TGTextView *p; p=(TGTextView*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGText),-1,-1,2,"fText=",0,"text buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGText),-1,-1,2,"fClipText=",0,"clipboard text buffer");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFont=",0,"text font");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxAscent=",0,"maximum ascent in font");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxDescent=",0,"maximum descent in font");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxWidth=",0,"maximum width of character in font");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,2,"fNormGC=",0,"graphics context for drawing text");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,2,"fSelGC=",0,"graphics context for drawing marked text");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-1,2,"fSelbackGC=",0,"graphics context for drawing marked background");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMarkedFromX=",0,"true if text is marked from x");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMarkedFromY=",0,"true if text is marker from y");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMarked=",0,"true if text is marked/selected");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMarking=",0,"true if in marking mode");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsSaved=",0,"true is content is saved");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReadOnly=",0,"text cannot be editted");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition),-1,-1,2,"fMarkedStart=",0,"start position of marked text");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition),-1,-1,2,"fMarkedEnd=",0,"end position of marked text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TViewTimer),-1,-1,2,"fScrollTimer=",0,"scrollbar timer");
   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,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultSelectedGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultSelectedBackgroundGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSearchType */
static void G__setup_memvarTGSearchType(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType));
   { TGSearchType *p; p=(TGSearchType*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fDirection)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fDirection=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fCaseSensitive)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCaseSensitive=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fBuffer)-(long)(p)),67,0,0,-1,-1,-1,1,"fBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fClose)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fClose=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTextEdit */
static void G__setup_memvarTGTextEdit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit));
   { TGTextEdit *p; p=(TGTextEdit*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLEInsertMode),-1,-2,1,G__FastAllocString(2048).Format("kInsert=%lldLL",(long long)TGTextEdit::kInsert).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLEInsertMode),-1,-2,1,G__FastAllocString(2048).Format("kReplace=%lldLL",(long long)TGTextEdit::kReplace).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_FILE_NEW=%lldLL",(long long)TGTextEdit::kM_FILE_NEW).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_FILE_OPEN=%lldLL",(long long)TGTextEdit::kM_FILE_OPEN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_FILE_CLOSE=%lldLL",(long long)TGTextEdit::kM_FILE_CLOSE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_FILE_SAVE=%lldLL",(long long)TGTextEdit::kM_FILE_SAVE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_FILE_SAVEAS=%lldLL",(long long)TGTextEdit::kM_FILE_SAVEAS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_FILE_PRINT=%lldLL",(long long)TGTextEdit::kM_FILE_PRINT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_EDIT_CUT=%lldLL",(long long)TGTextEdit::kM_EDIT_CUT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_EDIT_COPY=%lldLL",(long long)TGTextEdit::kM_EDIT_COPY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_EDIT_PASTE=%lldLL",(long long)TGTextEdit::kM_EDIT_PASTE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_EDIT_SELECTALL=%lldLL",(long long)TGTextEdit::kM_EDIT_SELECTALL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_SEARCH_FIND=%lldLL",(long long)TGTextEdit::kM_SEARCH_FIND).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_SEARCH_FINDAGAIN=%lldLL",(long long)TGTextEdit::kM_SEARCH_FINDAGAIN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kM_SEARCH_GOTO=%lldLL",(long long)TGTextEdit::kM_SEARCH_GOTO).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fCursor0GC=",0,"graphics context for erasing cursor");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fCursor1GC=",0,"graphics context for drawing cursor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCursorState=",0,"cursor state (1=drawn, 2=erased)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TViewTimer),-1,-1,2,"fCurBlink=",0,"cursor blink timer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPopupMenu),-1,-1,2,"fMenu=",0,"popup menu with editor actions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType),-1,-1,2,"fSearch=",0,"structure used by search dialog");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition),-1,-1,2,"fCurrent=",0,"current cursor position");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLEInsertMode),-1,-1,2,"fInsertMode=",0,"*OPTION={GetMethod=\"GetInsertMode\";SetMethod=\"SetInsertMode\";Items=(kInsert=\"&Insert\",kReplace=\"&Replace\")}*");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnableMenu=",0,"enable context menu with editor actions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditHist),-1,-1,2,"fHistory=",0,"undo manager");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnableCursorWithoutFocus=",0,"enable cursor visibility when focus went out from ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgCursor0GC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgCursor1GC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGSearchDialog */
static void G__setup_memvarTGSearchDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog));
   { TGSearchDialog *p; p=(TGSearchDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF4=",0,"sub frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL4=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL5=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL6=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL21=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL9=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL10=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,2,"fSearchButton=",0,"search button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,2,"fCancelButton=",0,"cancel button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGRadioButton),-1,-1,2,"fDirectionRadio[2]=",0,"search direction radio buttons");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCheckButton),-1,-1,2,"fCaseCheck=",0,"case check box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGroupFrame),-1,-1,2,"fG2=",0,"group frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry),-1,-1,2,"fSearch=",0,"search text entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextBuffer),-1,-1,2,"fBSearch=",0,"search text buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLabel),-1,-1,2,"fLSearch=",0,"label");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType),-1,-1,2,"fType=",0,"search type structure");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRetCode=",0,"return code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox),-1,-1,2,"fCombo=",0,"text entry combobox");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog),-1,-2,2,"fgSearchDialog=",0,"global singleton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGPrintDialog */
static void G__setup_memvarTGPrintDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog));
   { TGPrintDialog *p; p=(TGPrintDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,67,2,0,-1,-1,-1,2,"fPrinter=",0,"printer to be used");
   G__memvar_setup((void*)0,67,2,0,-1,-1,-1,2,"fPrintCommand=",0,"printer command to be used");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF4=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF5=",0,"sub frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL5=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL6=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL7=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL21=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGIcon),-1,-1,2,"fPrinterIcon=",0,"printer icon");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,2,"fPrintButton=",0,"print button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,2,"fCancelButton=",0,"cancel button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry),-1,-1,2,"fPrinterEntry=",0,"printer text entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry),-1,-1,2,"fPrintCommandEntry=",0,"command text entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextBuffer),-1,-1,2,"fBPrinter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextBuffer),-1,-1,2,"fBPrintCommand=",0,"printer and command text buffers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLabel),-1,-1,2,"fLPrinter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLabel),-1,-1,2,"fLPrintCommand=",0,"printer and command labels");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRetCode=",0,"return code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGGotoDialog */
static void G__setup_memvarTGGotoDialog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog));
   { TGGotoDialog *p; p=(TGGotoDialog*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame),-1,-1,2,"fF2=",0,"sub frames");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,2,"fGotoButton=",0,"goto button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGButton),-1,-1,2,"fCancelButton=",0,"cancel button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL5=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL6=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutHints),-1,-1,2,"fL21=",0,"layout hints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry),-1,-1,2,"fGoTo=",0,"goto line number entry widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGTextBuffer),-1,-1,2,"fBGoTo=",0,"goto line number text buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGLabel),-1,-1,2,"fLGoTo=",0,"goto label");
   G__memvar_setup((void*)0,76,0,0,-1,G__defined_typename("Long_t"),-1,2,"fRetCode=",0,"return code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDoubleSlider */
static void G__setup_memvarTGDoubleSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider));
   { TGDoubleSlider *p; p=(TGDoubleSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPos=",0,"logical position between fVmin and fVmax");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSmin=",0,"logical position of min value of Slider");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSmax=",0,"logical position of max value of Slider");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRelPos=",0,"slider position in pixel coordinates");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVmin=",0,"logical lower limit of slider");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVmax=",0,"logical upper limit of slider");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScale=",0,"tick mark scale");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScaleType=",0,"tick mark scale type (no, downright, both)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPressPoint=",0,"mouse position at button press event");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPressSmin=",0,"logical min position at button press event");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPressSmax=",0,"logical max position at button press event");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMove=",0,"1: move min value");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReversedScale=",0,"reverse which end is min and max");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMarkEnds=",0,"lines marking where stretch zones begin");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fSliderPic=",0,"picture to draw slider ends");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDoubleVSlider */
static void G__setup_memvarTGDoubleVSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider));
   { TGDoubleVSlider *p; p=(TGDoubleVSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fYp=",0,"vertical slider y position in pixel coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGDoubleHSlider */
static void G__setup_memvarTGDoubleHSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider));
   { TGDoubleHSlider *p; p=(TGDoubleHSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fXp=",0,"horizontal slider x position in pixel coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTreeLBEntry */
static void G__setup_memvarTGTreeLBEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry));
   { TGTreeLBEntry *p; p=(TGTreeLBEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGString),-1,-1,2,"fText=",0,"entry description");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGString),-1,-1,2,"fPath=",0,"entry path");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPic=",0,"entry picture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGSelectedPicture),-1,-1,2,"fSelPic=",0,"selected picture");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTWidth=",0,"width of entry text");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTHeight=",0,"height of entry text");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"true if active");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("GContext_t"),-1,2,"fNormGC=",0,"entry drawing context");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("FontStruct_t"),-1,2,"fFontStruct=",0,"font");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGFont),-1,-2,2,"fgDefaultFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGGC),-1,-2,2,"fgDefaultGC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRegion */
static void G__setup_memvarTGRegion(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegion));
   { TGRegion *p; p=(TGRegion*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGRegionData),-1,-1,2,"fData=",0,"data describing region");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGRegioncLcLERegionType),-1,-2,1,G__FastAllocString(2048).Format("kRectangle=%lldLL",(long long)TGRegion::kRectangle).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGRegioncLcLERegionType),-1,-2,1,G__FastAllocString(2048).Format("kEllipse=%lldLL",(long long)TGRegion::kEllipse).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGRegionWithId */
static void G__setup_memvarTGRegionWithId(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId));
   { TGRegionWithId *p; p=(TGRegionWithId*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fId=",0,"region id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),-1,-1,2,"fTip=",0,"tooltip");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGPopupMenu),-1,-1,2,"fPopup=",0,"popup menu");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGImageMap */
static void G__setup_memvarTGImageMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap));
   { TGImageMap *p; p=(TGImageMap*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGImageMapcLcLENavMode),-1,-2,1,G__FastAllocString(2048).Format("kNavRegions=%lldLL",(long long)TGImageMap::kNavRegions).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGImageMapcLcLENavMode),-1,-2,1,G__FastAllocString(2048).Format("kNavGrid=%lldLL",(long long)TGImageMap::kNavGrid).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,2,"fListOfRegions=",0,"list of regions");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGImageMapcLcLENavMode),-1,-1,2,"fNavMode=",0,"navigation mode");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_ECursor),-1,-1,2,"fCursorMouseOver=",0,"cursor shape in regions");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Gui2LN_ECursor),-1,-1,2,"fCursorMouseOut=",0,"cursor shape out of regions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastVisited=",0,"id of the last visited region");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip),-1,-1,2,"fMainTip=",0,"tooltip text for main region");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TList),-1,-1,2,"fTrash=",0,"collect all objects that need to be cleaned up");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGApplication */
static void G__setup_memvarTGApplication(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGApplication));
   { TGApplication *p; p=(TGApplication*)0x1000; if (p) { }
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fDisplay=",0,"display server to connect to");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGClient),-1,-1,4,"fClient=",0,"pointer to the client environment");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGXYLayoutHints */
static void G__setup_memvarTGXYLayoutHints(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints));
   { TGXYLayoutHints *p; p=(TGXYLayoutHints*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"x - position of widget");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"y - position of widget");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fW=",0,"width of widget");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH=",0,"height of widget");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFlag=",0,"rubber flag");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag),-1,-2,1,G__FastAllocString(2048).Format("kLRubberX=%lldLL",(long long)TGXYLayoutHints::kLRubberX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag),-1,-2,1,G__FastAllocString(2048).Format("kLRubberY=%lldLL",(long long)TGXYLayoutHints::kLRubberY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag),-1,-2,1,G__FastAllocString(2048).Format("kLRubberW=%lldLL",(long long)TGXYLayoutHints::kLRubberW).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag),-1,-2,1,G__FastAllocString(2048).Format("kLRubberH=%lldLL",(long long)TGXYLayoutHints::kLRubberH).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGXYLayout */
static void G__setup_memvarTGXYLayout(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout));
   { TGXYLayout *p; p=(TGXYLayout*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2LN_TGCompositeFrame),-1,-1,2,"fMain=",0,"container frame");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFirst=",0,"flag to determine the first call of Layout()");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFirstWidth=",0,"original width of the frame fMain");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFirstHeight=",0,"original height of the fram fMain");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTWidth=",0,"text width of a default character \"1234567890\" / 10");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTHeight=",0,"text height");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTripleVSlider */
static void G__setup_memvarTGTripleVSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider));
   { TGTripleVSlider *p; p=(TGTripleVSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCz=",0,"vertical pointer position in pixel coordinates");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSCz=",0,"vertical pointer position");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fConstrained=",0,"kTRUE if pointer is constrained to slider edges");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRelative=",0,"kTRUE if pointer position is relative to slider");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPointerPic=",0,"picture to draw pointer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGTripleHSlider */
static void G__setup_memvarTGTripleHSlider(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider));
   { TGTripleHSlider *p; p=(TGTripleHSlider*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCz=",0,"horizontal pointer position in pixel coordinates");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSCz=",0,"vertical pointer position");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fConstrained=",0,"kTRUE if pointer is constrained to slider edges");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRelative=",0,"kTRUE if pointer position is relative to slider");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Gui2LN_TGPicture),-1,-1,2,"fPointerPic=",0,"picture to draw pointer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Gui2() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTGResourcePool(void) {
   /* TGResourcePool */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool));
   G__memfunc_setup("TGResourcePool",1405,G__G__Gui2_133_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool), -1, 0, 1, 1, 1, 0, "U 'TGClient' - 0 - client", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGCPool",836,G__G__Gui2_133_0_2, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGCPool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontPool",1105,G__G__Gui2_133_0_3, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicturePool",1430,G__G__Gui2_133_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicturePool), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWhiteColor",1312,G__G__Gui2_133_0_5, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlackColor",1276,G__G__Gui2_133_0_6, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFgndColor",1673,G__G__Gui2_133_0_7, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBgndColor",1669,G__G__Gui2_133_0_8, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameHiliteColor",1897,G__G__Gui2_133_0_9, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameShadowColor",1904,G__G__Gui2_133_0_10, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentFgndColor",2013,G__G__Gui2_133_0_11, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentBgndColor",2009,G__G__Gui2_133_0_12, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedFgndColor",1991,G__G__Gui2_133_0_13, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedBgndColor",1987,G__G__Gui2_133_0_14, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTipFgndColor",1483,G__G__Gui2_133_0_15, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTipBgndColor",1479,G__G__Gui2_133_0_16, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFont",1404,G__G__Gui2_133_0_17, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuFont",1100,G__G__Gui2_133_0_18, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuHiliteFont",1707,G__G__Gui2_133_0_19, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentFixedFont",2022,G__G__Gui2_133_0_20, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentPropFont",1943,G__G__Gui2_133_0_21, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIconFont",1088,G__G__Gui2_133_0_22, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatusFont",1339,G__G__Gui2_133_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWhiteGC",939,G__G__Gui2_133_0_24, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlackGC",903,G__G__Gui2_133_0_25, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameGC",917,G__G__Gui2_133_0_26, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBckgndGC",1502,G__G__Gui2_133_0_27, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameHiliteGC",1524,G__G__Gui2_133_0_28, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameShadowGC",1531,G__G__Gui2_133_0_29, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFocusHiliteGC",1545,G__G__Gui2_133_0_30, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentGC",1257,G__G__Gui2_133_0_31, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentBckgndGC",1842,G__G__Gui2_133_0_32, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedGC",1235,G__G__Gui2_133_0_33, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedBckgndGC",1820,G__G__Gui2_133_0_34, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTipGC",727,G__G__Gui2_133_0_35, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheckeredPixmap",1805,G__G__Gui2_133_0_36, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheckeredBitmap",1787,G__G__Gui2_133_0_37, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameBckgndPicture",2096,G__G__Gui2_133_0_38, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDocumentBckgndPicture",2436,G__G__Gui2_133_0_39, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultCursor",1635,G__G__Gui2_133_0_40, 107, -1, G__defined_typename("Cursor_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGrabCursor",1306,G__G__Gui2_133_0_41, 107, -1, G__defined_typename("Cursor_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextCursor",1347,G__G__Gui2_133_0_42, 107, -1, G__defined_typename("Cursor_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaitCursor",1331,G__G__Gui2_133_0_43, 107, -1, G__defined_typename("Cursor_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultColormap",1826,G__G__Gui2_133_0_44, 107, -1, G__defined_typename("Colormap_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMimeTypes",1213,G__G__Gui2_133_0_45, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipboard",1200,G__G__Gui2_133_0_46, 107, -1, G__defined_typename("Atom_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_133_0_47, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGResourcePool::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_133_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGResourcePool::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_133_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGResourcePool::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_133_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGResourcePool::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_133_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_133_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGResourcePool::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_133_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGResourcePool::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_133_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGResourcePool::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_133_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGResourcePool::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGResourcePool", 1405, G__G__Gui2_133_0_59, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_TGResourcePool), -1, 0, 1, 1, 1, 0, "u 'TGResourcePool' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGResourcePool", 1531, G__G__Gui2_133_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFontPool(void) {
   /* TGFontPool */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool));
   G__memfunc_setup("TGFontPool",972,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool), -1, 0, 1, 1, 4, 0, "u 'TGFontPool' - 11 - fp", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool), -1, 1, 1, 1, 4, 0, "u 'TGFontPool' - 11 - fp", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetUid",578,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 2, 1, "C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseXLFD",809,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"C - - 10 - string U 'XLFDAttributes_t' - 0 - xa", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontFromAttributes",2162,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 2, 1, 2, 0, 
"U 'FontAttributes_t' - 0 - fa U 'TGFont' - 0 - fontPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindStateNum",1202,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 0, 
"U 'FontStateMap_t' - 10 - map C - - 10 - strKey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindStateString",1529,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 2, 1, 2, 1, 
"U 'FontStateMap_t' - 10 - map i - - 0 - numKey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FieldSpecified",1392,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNativeFont",1310,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 2, 1, 2, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' fixedDefault", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeFont",789,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 3, 1, 2, 0, 
"U 'TGFont' - 0 - font k - 'FontStruct_t' 0 - fontStruct "
"C - - 10 - fontName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFontPool",972,G__G__Gui2_138_0_11, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFontPool), -1, 0, 1, 1, 1, 0, "U 'TGClient' - 0 - client", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui2_138_0_12, 85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_138_0_13, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 1, 1, 1, 0, "U 'TGFont' - 10 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui2_138_0_14, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 1, 1, 1, 0, "k - 'FontStruct_t' 0 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__Gui2_138_0_15, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 4, 1, 1, 0, 
"C - - 10 - family i - 'Int_t' 0 - ptsize "
"i - 'Int_t' 0 - weight i - 'Int_t' 0 - slant", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeFont",793,G__G__Gui2_138_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFont' - 10 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindFont",792,G__G__Gui2_138_0_17, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 1, 1, 1, 8, "k - 'FontStruct_t' 0 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindFontByHandle",1567,G__G__Gui2_138_0_18, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 1, 1, 1, 8, "k - 'FontH_t' 0 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttributeInfo",1632,G__G__Gui2_138_0_19, 67, -1, -1, 2, 1, 1, 1, 0, "U 'FontAttributes_t' - 10 - fa", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeAttributeInfo",1730,G__G__Gui2_138_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 2 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontFamilies",1505,G__G__Gui2_138_0_21, 67, -1, -1, 2, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FreeFontFamilies",1603,G__G__Gui2_138_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 2 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseFontName",1299,G__G__Gui2_138_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - string U 'FontAttributes_t' - 0 - fa", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NameOfFont",973,G__G__Gui2_138_0_24, 67, -1, -1, 0, 1, 1, 1, 1, "U 'TGFont' - 0 - font", (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__Gui2_138_0_26, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFontPool::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_138_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontPool::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_138_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFontPool::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_138_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFontPool::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_138_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_138_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontPool::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_138_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFontPool::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_138_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontPool::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_138_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFontPool::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFontPool", 1098, G__G__Gui2_138_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFont(void) {
   /* TGFont */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFont));
   G__memfunc_setup("TGFont",562,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 1, 1, 2, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFont",562,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFont), -1, 0, 1, 1, 2, 0, "u 'TGFont' - 11 - font", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGFont' - 11 - font", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("NewChunk",803,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui2LN_LayoutChunk_t), -1, 0, 7, 1, 2, 8, 
"U 'TGTextLayout' - 0 - layout I - - 0 - maxPtr "
"C - - 10 - start i - - 0 - numChars "
"i - - 0 - curX i - - 0 - newX "
"i - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontHandle",1283,G__G__Gui2_139_0_5, 107, -1, G__defined_typename("FontH_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui2_139_0_6, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Gui2_139_0_7, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontMetrics",1422,G__G__Gui2_139_0_8, 121, -1, -1, 0, 1, 1, 1, 8, "U 'FontMetrics_t' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontAttributes",1758,G__G__Gui2_139_0_9, 117, G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PostscriptFontName",1875,G__G__Gui2_139_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TString' - 0 - dst", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TextWidth",933,G__G__Gui2_139_0_11, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - string i - 'Int_t' 0 '-1' numChars", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XTextWidth",1021,G__G__Gui2_139_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"C - - 10 - string i - 'Int_t' 0 '-1' numChars", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TextHeight",1022,G__G__Gui2_139_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnderlineChars",1431,G__G__Gui2_139_0_14, 121, -1, -1, 0, 7, 1, 1, 8, 
"k - 'Drawable_t' 0 - dst k - 'GContext_t' 0 - gc "
"C - - 10 - string i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y i - 'Int_t' 0 - firstChar "
"i - 'Int_t' 0 - lastChar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeTextLayout",1792,G__G__Gui2_139_0_15, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout), -1, 0, 7, 1, 1, 8, 
"C - - 10 - string i - 'Int_t' 0 - numChars "
"i - 'Int_t' 0 - wrapLength i - 'Int_t' 0 - justify "
"i - 'Int_t' 0 - flags H - 'UInt_t' 0 - width "
"H - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MeasureChars",1219,G__G__Gui2_139_0_16, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"C - - 10 - source i - 'Int_t' 0 - numChars "
"i - 'Int_t' 0 - maxLength i - 'Int_t' 0 - flags "
"I - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCharsExp",1196,G__G__Gui2_139_0_17, 121, -1, -1, 0, 6, 1, 1, 8, 
"k - 'Drawable_t' 0 - dst k - 'GContext_t' 0 - gc "
"C - - 10 - source i - 'Int_t' 0 - numChars "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawChars",895,G__G__Gui2_139_0_18, 121, -1, -1, 0, 6, 1, 1, 8, 
"k - 'Drawable_t' 0 - dst k - 'GContext_t' 0 - gc "
"C - - 10 - source i - 'Int_t' 0 - numChars "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_139_0_21, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFont::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_139_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFont::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_139_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFont::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_139_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFont::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_139_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_139_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFont::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_139_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFont::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_139_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFont::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_139_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFont::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFont", 688, G__G__Gui2_139_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGMimeTypes(void) {
   /* TGMimeTypes */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes));
   G__memfunc_setup("TGMimeTypes",1080,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes), -1, 0, 1, 1, 2, 0, "u 'TGMimeTypes' - 11 - gmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes), -1, 1, 1, 1, 2, 0, "u 'TGMimeTypes' - 11 - gmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Find",385,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGMime), -1, 0, 1, 1, 2, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGMimeTypes",1080,G__G__Gui2_140_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGMimeTypes), -1, 0, 2, 1, 1, 0, 
"U 'TGClient' - 0 - client C - - 10 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveMimes",906,G__G__Gui2_140_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasChanged",966,G__G__Gui2_140_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddType",683,G__G__Gui2_140_0_7, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - type C - - 10 - pat "
"C - - 10 - icon C - - 10 - sicon "
"C - - 10 - action", (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("GetAction",894,G__G__Gui2_140_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 0 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Gui2_140_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIcon",681,G__G__Gui2_140_0_11, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 2, 1, 1, 1, 
"C - - 10 - filename g - 'Bool_t' 0 - small_icon", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_140_0_12, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGMimeTypes::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_140_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMimeTypes::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_140_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGMimeTypes::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_140_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGMimeTypes::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_140_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__Gui2_140_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMimeTypes::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_140_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMimeTypes::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_140_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGMimeTypes::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_140_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGMimeTypes::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGMimeTypes", 1206, G__G__Gui2_140_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncFontMetrics_t(void) {
   /* FontMetrics_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t));
   // automatic default constructor
   G__memfunc_setup("FontMetrics_t", 1345, G__G__Gui2_169_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FontMetrics_t", 1345, G__G__Gui2_169_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t), -1, 0, 1, 1, 1, 0, "u 'FontMetrics_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FontMetrics_t", 1471, G__G__Gui2_169_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui2_169_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Gui2LN_FontMetrics_t), -1, 1, 1, 1, 1, 0, "u 'FontMetrics_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncFontAttributes_t(void) {
   /* FontAttributes_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t));
   G__memfunc_setup("FontAttributes_t",1681,G__G__Gui2_170_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FontAttributes_t",1681,G__G__Gui2_170_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t), -1, 0, 1, 1, 1, 0, "u 'FontAttributes_t' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Gui2_170_0_3, 117, G__get_linked_tagnum(&G__G__Gui2LN_FontAttributes_t), -1, 1, 1, 1, 1, 0, "u 'FontAttributes_t' - 11 - f", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FontAttributes_t", 1807, G__G__Gui2_170_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextLayout(void) {
   /* TGTextLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout));
   G__memfunc_setup("TGTextLayout",1214,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout), -1, 0, 1, 1, 2, 0, "u 'TGTextLayout' - 11 - tlayout", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGTextLayout' - 11 - tlayout", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGTextLayout",1214,G__G__Gui2_172_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLayout), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawText",819,G__G__Gui2_172_0_4, 121, -1, -1, 0, 6, 1, 1, 8, 
"k - 'Drawable_t' 0 - dst k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - firstChar i - 'Int_t' 0 - lastChar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnderlineChar",1316,G__G__Gui2_172_0_5, 121, -1, -1, 0, 5, 1, 1, 8, 
"k - 'Drawable_t' 0 - dst k - 'GContext_t' 0 - gc "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - underline", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PointToChar",1099,G__G__Gui2_172_0_6, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CharBbox",777,G__G__Gui2_172_0_7, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - index I - 'Int_t' 0 - x "
"I - 'Int_t' 0 - y I - 'Int_t' 0 - w "
"I - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistanceToText",1427,G__G__Gui2_172_0_8, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntersectText",1366,G__G__Gui2_172_0_9, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - w i - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToPostscript",1278,G__G__Gui2_172_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TString' - 0 - dst", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_172_0_11, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_172_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_172_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_172_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_172_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__Gui2_172_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_172_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_172_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_172_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextLayout", 1340, G__G__Gui2_172_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVFileSplitter(void) {
   /* TGVFileSplitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter));
   G__memfunc_setup("TGVFileSplitter",1480,G__G__Gui2_202_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGVFileSplitter), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '4' 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("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("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("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("LayoutHeader",1223,G__G__Gui2_202_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("LayoutListView",1461,G__G__Gui2_202_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("ButtonPressed",1362,G__G__Gui2_202_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("ButtonReleased",1441,G__G__Gui2_202_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_202_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGVFileSplitter' - 0 - frame", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_202_0_11, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVFileSplitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_202_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVFileSplitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_202_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVFileSplitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_202_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVFileSplitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_202_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__Gui2_202_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVFileSplitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_202_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVFileSplitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_202_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVFileSplitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_202_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVFileSplitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVFileSplitter", 1606, G__G__Gui2_202_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGToolTip(void) {
   /* TGToolTip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip));
   G__memfunc_setup("TGToolTip",870,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 0, 1, 1, 4, 0, "u 'TGToolTip' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 1, 1, 1, 4, 0, "u 'TGToolTip' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGToolTip",870,G__G__Gui2_225_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGFrame' - 10 '0' f "
"C - - 10 '0' text l - 'Long_t' 0 '350' delayms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGToolTip",870,G__G__Gui2_225_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TBox' - 10 - b "
"C - - 10 - text l - 'Long_t' 0 - delayms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGToolTip",870,G__G__Gui2_225_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 0, 3, 1, 1, 0, 
"U 'TBox' - 10 - b C - - 10 - text "
"l - 'Long_t' 0 - delayms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGToolTip",870,G__G__Gui2_225_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"C - - 10 - text l - 'Long_t' 0 - delayms", (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("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("Show",417,G__G__Gui2_225_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Hide",378,G__G__Gui2_225_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Gui2_225_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Gui2_225_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 10 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__Gui2_225_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - new_text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__G__Gui2_225_0_14, 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("SetDelay",795,G__G__Gui2_225_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - delayms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui2_225_0_16, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_225_0_17, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGToolTip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_225_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGToolTip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_225_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGToolTip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_225_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGToolTip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_225_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__Gui2_225_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGToolTip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_225_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGToolTip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_225_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGToolTip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_225_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGToolTip::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGToolTip", 996, G__G__Gui2_225_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGScrollBarElement(void) {
   /* TGScrollBarElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement));
   G__memfunc_setup("TGScrollBarElement",1769,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement), -1, 0, 1, 1, 4, 0, "u 'TGScrollBarElement' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement), -1, 1, 1, 1, 4, 0, "u 'TGScrollBarElement' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGScrollBarElement",1769,G__G__Gui2_234_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGPicture' - 10 '0' pic "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h "
"h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetState",813,G__G__Gui2_234_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - state", (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("SetEnabled",983,G__G__Gui2_234_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEnabled",871,G__G__Gui2_234_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_234_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGScrollBarElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_234_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGScrollBarElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_234_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGScrollBarElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_234_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGScrollBarElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_234_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__Gui2_234_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGScrollBarElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_234_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGScrollBarElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_234_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGScrollBarElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_234_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGScrollBarElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGScrollBarElement", 1895, G__G__Gui2_234_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGScrollBar(void) {
   /* TGScrollBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar), -1, 1, 1, 1, 4, 0, "u 'TGScrollBar' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetBckgndPixmap",1496,G__G__Gui2_235_0_3, 107, -1, G__defined_typename("Pixmap_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixmap_t (*)())(&TGScrollBar::GetBckgndPixmap) ), 0);
   G__memfunc_setup("GetScrollBarWidth",1700,G__G__Gui2_235_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TGScrollBar::GetScrollBarWidth) ), 0);
   G__memfunc_setup("GrabPointer",1117,G__G__Gui2_235_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - grab", (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, 3);
   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, 3);
   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, 3);
   G__memfunc_setup("SetRange",793,G__G__Gui2_235_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - range i - 'Int_t' 0 - page_size", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPosition",1153,G__G__Gui2_235_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPosition",1141,G__G__Gui2_235_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPageSize",1080,G__G__Gui2_235_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,G__G__Gui2_235_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("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("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("ChangeBackground",1606,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - back", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAccelerated",1401,G__G__Gui2_235_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAccelerated",1289,G__G__Gui2_235_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MapSubwindows",1363,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHead",658,G__G__Gui2_235_0_24, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTail",682,G__G__Gui2_235_0_25, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlider",899,G__G__Gui2_235_0_26, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBarElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PositionChanged",1535,G__G__Gui2_235_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("RangeChanged",1175,G__G__Gui2_235_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - range", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("PageSizeChanged",1474,G__G__Gui2_235_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - range", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetSmallIncrement",1726,G__G__Gui2_235_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSmallIncrement",1738,G__G__Gui2_235_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - increment", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_235_0_32, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGScrollBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_235_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGScrollBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_235_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGScrollBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_235_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGScrollBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_235_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__Gui2_235_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGScrollBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_235_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGScrollBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_235_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGScrollBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_235_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGScrollBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGScrollBar", 1181, G__G__Gui2_235_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHScrollBar(void) {
   /* TGHScrollBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar));
   G__memfunc_setup("TGHScrollBar",1127,G__G__Gui2_236_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar), -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 'kHorizontalFrame' 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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - range i - 'Int_t' 0 - page_size", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", "*MENU* *GETTER=GetPosition", (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__Gui2_236_0_9, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHScrollBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_236_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHScrollBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_236_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHScrollBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_236_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHScrollBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_236_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__Gui2_236_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHScrollBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_236_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHScrollBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_236_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHScrollBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_236_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHScrollBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHScrollBar", 1253, G__G__Gui2_236_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVScrollBar(void) {
   /* TGVScrollBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar));
   G__memfunc_setup("TGVScrollBar",1141,G__G__Gui2_237_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar), -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 'kVerticalFrame' 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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - range i - 'Int_t' 0 - page_size", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", "*MENU*  *GETTER=GetPosition", (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__Gui2_237_0_9, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVScrollBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_237_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVScrollBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_237_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVScrollBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_237_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVScrollBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_237_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__Gui2_237_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVScrollBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_237_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVScrollBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_237_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVScrollBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_237_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVScrollBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVScrollBar", 1267, G__G__Gui2_237_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGViewPort(void) {
   /* TGViewPort */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort));
   G__memfunc_setup("TGViewPort",987,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort), -1, 0, 1, 1, 4, 0, "u 'TGViewPort' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort), -1, 1, 1, 1, 4, 0, "u 'TGViewPort' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGViewPort",987,G__G__Gui2_238_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort), -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("GetContainer",1219,G__G__Gui2_238_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetContainer",1231,G__G__Gui2_238_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (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("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__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHPos",678,G__G__Gui2_238_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - xpos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVPos",692,G__G__Gui2_238_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ypos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPos",606,G__G__Gui2_238_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - xpos i - 'Int_t' 0 - ypos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHPos",666,G__G__Gui2_238_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVPos",680,G__G__Gui2_238_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   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("Class",502,G__G__Gui2_238_0_15, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGViewPort::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_238_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGViewPort::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_238_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGViewPort::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_238_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGViewPort::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_238_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__Gui2_238_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGViewPort::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_238_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGViewPort::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_238_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGViewPort::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_238_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGViewPort::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGViewPort", 1113, G__G__Gui2_238_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGCanvas(void) {
   /* TGCanvas */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas));
   G__memfunc_setup("TGCanvas",759,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas), -1, 0, 1, 1, 4, 0, "u 'TGCanvas' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas), -1, 1, 1, 1, 4, 0, "u 'TGCanvas' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGCanvas",759,G__G__Gui2_239_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas), -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 'kSunkenFrame|kDoubleBorder' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContainer",1219,G__G__Gui2_239_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewPort",1120,G__G__Gui2_239_0_5, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHScrollbar",1292,G__G__Gui2_239_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVScrollbar",1306,G__G__Gui2_239_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFrame",756,G__G__Gui2_239_0_8, 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("SetContainer",1231,G__G__Gui2_239_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (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("DrawBorder",1004,(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("ClearViewPort",1319,G__G__Gui2_239_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHsbPosition",1426,G__G__Gui2_239_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVsbPosition",1440,G__G__Gui2_239_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHsbPosition",1438,G__G__Gui2_239_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVsbPosition",1452,G__G__Gui2_239_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScrolling",1241,G__G__Gui2_239_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - scrolling", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScrolling",1229,G__G__Gui2_239_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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("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__Gui2_239_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGCanvas::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_239_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCanvas::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_239_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGCanvas::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_239_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGCanvas::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_239_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__Gui2_239_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCanvas::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_239_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCanvas::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_239_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGCanvas::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_239_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGCanvas::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGCanvas", 885, G__G__Gui2_239_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListView(void) {
   /* TGListView */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListView));
   G__memfunc_setup("TGListView",978,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListView), -1, 0, 1, 1, 4, 0, "u 'TGListView' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGListView), -1, 1, 1, 1, 4, 0, "u 'TGListView' - 11 - -", "Not implemented", (void*) NULL, 0);
   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("GetDefaultGC",1135,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGListView",978,G__G__Gui2_243_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListView), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h h - 'UInt_t' 0 'kSunkenFrame|kDoubleBorder' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeColumns",1363,G__G__Gui2_243_0_6, 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("LayoutHeader",1223,G__G__Gui2_243_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - head", (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("ScrollHeader",1208,G__G__Gui2_243_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetContainer",1231,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AdjustHeaders",1319,G__G__Gui2_243_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHeaders",1000,G__G__Gui2_243_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHeader",885,G__G__Gui2_243_0_14, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - hmode "
"i - 'Int_t' 0 - cmode i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultHeaders",1709,G__G__Gui2_243_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetViewMode",1100,G__G__Gui2_243_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EListViewMode' - 0 - viewMode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHeaderButtons",1624,G__G__Gui2_243_0_17, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTextButton), -1, 2, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumColumns",1329,G__G__Gui2_243_0_18, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewMode",1088,G__G__Gui2_243_0_19, 105, G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeader",873,G__G__Gui2_243_0_20, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - idx", (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("SetIncrements",1348,G__G__Gui2_243_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - hInc i - 'Int_t' 0 - vInc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultColumnWidth",2143,G__G__Gui2_243_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGVFileSplitter' - 0 - splitter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxItemSize",1392,G__G__Gui2_243_0_24, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectionChanged",1616,G__G__Gui2_243_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_243_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLVEntry' - 0 - entry i - 'Int_t' 0 - btn", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_243_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGLVEntry' - 0 - entry i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_243_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLVEntry' - 0 - entry i - 'Int_t' 0 - btn", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_243_0_29, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGLVEntry' - 0 - entry i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_243_0_30, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListView::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_243_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListView::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_243_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListView::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_243_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListView::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_243_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_243_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListView::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_243_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListView::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_243_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListView::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_243_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListView::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListView", 1104, G__G__Gui2_243_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGContainer(void) {
   /* TGContainer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGContainer));
   G__memfunc_setup("GetLineGC",818,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (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("ActivateItem",1216,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrameElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeActivateItem",1385,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrameElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SearchPattern",1332,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OnAutoScroll",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RepeatSearch",1207,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGContainer",1086,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGContainer), -1, 0, 1, 1, 4, 0, "u 'TGContainer' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGContainer), -1, 1, 1, 1, 4, 0, "u 'TGContainer' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGContainer",1086,G__G__Gui2_244_0_10, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGContainer), -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 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGContainer",1086,G__G__Gui2_244_0_11, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGContainer), -1, 0, 3, 1, 1, 0, 
"U 'TGCanvas' - 0 - p h - 'UInt_t' 0 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRegion",1010,G__G__Gui2_244_0_12, 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("ClearViewPort",1319,G__G__Gui2_244_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Associate",924,G__G__Gui2_244_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AdjustPosition",1472,G__G__Gui2_244_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPagePosition",1534,G__G__Gui2_244_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGPosition' - 11 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPagePosition",1534,G__G__Gui2_244_0_17, 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("SetPageDimension",1615,G__G__Gui2_244_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGDimension' - 11 - dim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPageDimension",1615,G__G__Gui2_244_0_19, 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("RemoveAll",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveItem",1021,G__G__Gui2_244_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - item", (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("GetCanvas",892,G__G__Gui2_244_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMessageWindow",1629,G__G__Gui2_244_0_24, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGWindow), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPagePosition",1522,G__G__Gui2_244_0_25, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPageDimension",1603,G__G__Gui2_244_0_26, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NumSelected",1113,G__G__Gui2_244_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NumItems",818,G__G__Gui2_244_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFrame",876,G__G__Gui2_244_0_29, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrameElement), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"g - 'Bool_t' 0 'kTRUE' exclude", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFrameByName",1448,G__G__Gui2_244_0_30, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHScrollbar",1292,G__G__Gui2_244_0_31, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGHScrollBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVScrollbar",1306,G__G__Gui2_244_0_32, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHsbPosition",1438,G__G__Gui2_244_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVsbPosition",1452,G__G__Gui2_244_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineUp",589,G__G__Gui2_244_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineDown",800,G__G__Gui2_244_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineLeft",787,G__G__Gui2_244_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineRight",902,G__G__Gui2_244_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PageUp",578,G__G__Gui2_244_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PageDown",789,G__G__Gui2_244_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Home",393,G__G__Gui2_244_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("End",279,G__G__Gui2_244_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Search",598,G__G__Gui2_244_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' close", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindItem",784,G__G__Gui2_244_0_44, 89, -1, -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - name g - 'Bool_t' 0 'kTRUE' direction "
"g - 'Bool_t' 0 'kTRUE' caseSensitive g - 'Bool_t' 0 'kFALSE' subString", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextSelected",1512,G__G__Gui2_244_0_45, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 1, 1, 1, 1, "Y - - 2 - current", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLastActive",1296,G__G__Gui2_244_0_46, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -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("HandleDNDFinished",1612,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleExpose",1216,(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("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("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("GetObjPicture",1303,G__G__Gui2_244_0_54, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 1, 1, 1, 1, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDragPixmap",1305,G__G__Gui2_244_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - pic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectAll",889,G__G__Gui2_244_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("UnSelectAll",1084,G__G__Gui2_244_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("InvertSelection",1566,G__G__Gui2_244_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,G__G__Gui2_244_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("SpacePressed",1218,G__G__Gui2_244_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("KeyPressed",1023,G__G__Gui2_244_0_61, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGFrame' - 0 - - h - 'UInt_t' 0 - keysym "
"h - 'UInt_t' 0 - mask", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("OnMouseOver",1122,G__G__Gui2_244_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CurrentChanged",1421,G__G__Gui2_244_0_63, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("CurrentChanged",1421,G__G__Gui2_244_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 - f", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_244_0_65, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f i - 'Int_t' 0 - btn", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_244_0_66, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - f i - 'Int_t' 0 - btn", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_244_0_67, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - f i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_244_0_68, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGFrame' - 0 - f i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_244_0_69, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGContainer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_244_0_70, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGContainer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_244_0_71, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGContainer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_244_0_72, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGContainer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_244_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_244_0_77, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGContainer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_244_0_78, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGContainer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_244_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGContainer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_244_0_80, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGContainer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGContainer", 1212, G__G__Gui2_244_0_81, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListBox(void) {
   /* TGListBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListBox));
   G__memfunc_setup("TGListBox",864,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListBox), -1, 0, 1, 1, 4, 0, "u 'TGListBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGListBox), -1, 0, 1, 1, 4, 0, "u 'TGListBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetContainer",1231,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitListBox",1113,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGListBox",864,G__G__Gui2_246_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListBox), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEntry",795,G__G__Gui2_246_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGString' - 0 - s i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntry",795,G__G__Gui2_246_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntry",795,G__G__Gui2_246_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntrySort",1219,G__G__Gui2_246_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGString' - 0 - s i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntrySort",1219,G__G__Gui2_246_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntrySort",1219,G__G__Gui2_246_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_246_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGString' - 0 - s i - 'Int_t' 0 - id "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_246_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - id "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_246_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewEntry",828,G__G__Gui2_246_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"Entry\"' s", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemoveEntry",1152,G__G__Gui2_246_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' id", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemoveAll",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemoveEntries",1352,G__G__Gui2_246_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - from_ID i - 'Int_t' 0 - to_ID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeBackground",1606,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - back", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTopEntry",1137,G__G__Gui2_246_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMultipleSelections",2193,G__G__Gui2_246_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' multi", "*TOGGLE* *GETTER=GetMultipleSelections", (void*) NULL, 1);
   G__memfunc_setup("GetMultipleSelections",2181,G__G__Gui2_246_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberOfEntries",1816,G__G__Gui2_246_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,G__G__Gui2_246_0_24, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindEntry",915,G__G__Gui2_246_0_25, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 1, 1, 1, 8, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContainer",1219,G__G__Gui2_246_0_26, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetViewPort",1120,G__G__Gui2_246_0_27, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGViewPort), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScrollBar",1188,G__G__Gui2_246_0_28, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGScrollBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVScrollbar",1306,G__G__Gui2_246_0_29, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar), -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("Resize",626,(G__InterfaceMethod) NULL,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("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 - w h - 'UInt_t' 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("SetLayoutManager",1637,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLayoutManager' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SortByName",996,G__G__Gui2_246_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ascend", "*MENU*icon=bld_sortup.png*", (void*) NULL, 1);
   G__memfunc_setup("IntegralHeight",1423,G__G__Gui2_246_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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("Select",608,G__G__Gui2_246_0_40, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - id g - 'Bool_t' 0 'kTRUE' sel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelected",1097,G__G__Gui2_246_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelection",1222,G__G__Gui2_246_0_42, 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("GetSelectedEntry",1627,G__G__Gui2_246_0_43, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedEntries",1827,G__G__Gui2_246_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - selected", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetItemVsize",1216,G__G__Gui2_246_0_45, 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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_246_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - widgetId i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_246_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_246_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - txt", "*SIGNAL", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_246_0_50, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - widgetId i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_246_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_246_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - txt", "*SIGNAL", (void*) NULL, 1);
   G__memfunc_setup("SelectionChanged",1616,G__G__Gui2_246_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_246_0_54, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_246_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_246_0_56, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_246_0_57, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_246_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__Gui2_246_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_246_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_246_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_246_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListBox", 990, G__G__Gui2_246_0_66, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLBEntry(void) {
   /* TGLBEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLBEntry",827,G__G__Gui2_247_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (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 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Toggle",610,G__G__Gui2_247_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Gui2_247_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLBEntry' - 0 - -", "this is needed on TGComboBoxes :(", (void*) NULL, 1);
   G__memfunc_setup("EntryId",703,G__G__Gui2_247_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (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 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_247_0_9, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLBEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_247_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_247_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLBEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_247_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLBEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_247_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__Gui2_247_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_247_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_247_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_247_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLBEntry", 953, G__G__Gui2_247_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextLBEntry(void) {
   /* TGTextLBEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGTextLBEntry",1248,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry), -1, 0, 1, 1, 4, 0, "u 'TGTextLBEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry), -1, 1, 1, 1, 4, 0, "u 'TGTextLBEntry' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui2_248_0_4, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGTextLBEntry::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui2_248_0_5, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGTextLBEntry::GetDefaultGC) ), 0);
   G__memfunc_setup("TGTextLBEntry",1248,G__G__Gui2_248_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLBEntry), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGString' - 0 '0' s "
"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kHorizontalFrame' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,G__G__Gui2_248_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__Gui2_248_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGString' - 0 - new_text", (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("SetTitle",814,G__G__Gui2_248_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLBEntry' - 0 - e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNormGC",838,G__G__Gui2_248_0_14, 107, -1, G__defined_typename("GContext_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontStruct",1340,G__G__Gui2_248_0_15, 107, -1, G__defined_typename("FontStruct_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__Gui2_248_0_17, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextLBEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_248_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLBEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_248_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextLBEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_248_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextLBEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_248_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__Gui2_248_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLBEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_248_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextLBEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_248_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLBEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_248_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextLBEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextLBEntry", 1374, G__G__Gui2_248_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLineLBEntry(void) {
   /* TGLineLBEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry));
   G__memfunc_setup("TGLineLBEntry",1219,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry), -1, 0, 1, 1, 4, 0, "u 'TGLineLBEntry' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry), -1, 0, 1, 1, 4, 0, "u 'TGLineLBEntry' - 11 - -", "Not implemented", (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("TGLineLBEntry",1219,G__G__Gui2_249_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLineLBEntry), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"C - - 10 '0' str h - 'UInt_t' 0 '0' w "
"s - 'Style_t' 0 '0' s h - 'UInt_t' 0 'kHorizontalFrame' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineWidth",1192,G__G__Gui2_249_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,G__G__Gui2_249_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - width", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineStyle",1209,G__G__Gui2_249_0_8, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineStyle",1221,G__G__Gui2_249_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - style", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineGC",818,G__G__Gui2_249_0_10, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLBEntry' - 0 - e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_249_0_13, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLineLBEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_249_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineLBEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_249_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLineLBEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_249_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLineLBEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_249_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__Gui2_249_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineLBEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_249_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLineLBEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_249_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineLBEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_249_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLineLBEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLineLBEntry", 1345, G__G__Gui2_249_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGIconLBEntry(void) {
   /* TGIconLBEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry));
   G__memfunc_setup("TGIconLBEntry",1220,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry), -1, 0, 1, 1, 4, 0, "u 'TGIconLBEntry' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry), -1, 0, 1, 1, 4, 0, "u 'TGIconLBEntry' - 11 - -", "Not implemented", (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("TGIconLBEntry",1220,G__G__Gui2_250_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGIconLBEntry), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"C - - 10 '0' str U 'TGPicture' - 10 '0' pic "
"h - 'UInt_t' 0 '0' w s - 'Style_t' 0 '0' s "
"h - 'UInt_t' 0 'kHorizontalFrame' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPicture",1020,G__G__Gui2_250_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPicture",1032,G__G__Gui2_250_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 '0' pic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLBEntry' - 0 - e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_250_0_10, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGIconLBEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_250_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIconLBEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_250_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGIconLBEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_250_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGIconLBEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_250_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_250_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIconLBEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_250_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGIconLBEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_250_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGIconLBEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_250_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGIconLBEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGIconLBEntry", 1346, G__G__Gui2_250_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLBContainer(void) {
   /* TGLBContainer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer));
   G__memfunc_setup("TGLBContainer",1228,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer), -1, 0, 1, 1, 4, 0, "u 'TGLBContainer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer), -1, 0, 1, 1, 4, 0, "u 'TGLBContainer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("OnAutoScroll",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (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("TGLBContainer",1228,G__G__Gui2_251_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLBContainer), -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 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEntry",795,G__G__Gui2_251_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntrySort",1219,G__G__Gui2_251_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_251_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveEntry",1152,G__G__Gui2_251_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveEntries",1352,G__G__Gui2_251_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - from_ID i - 'Int_t' 0 - to_ID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAll",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActivateItem",1216,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGFrameElement' - 0 - el", (char*)NULL, (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("SetListBox",1009,G__G__Gui2_251_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListBox' - 0 - lb", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListBox",997,G__G__Gui2_251_0_15, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListBox), -1, 0, 0, 1, 1, 8, "", (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("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("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("GetSelected",1097,G__G__Gui2_251_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelection",1222,G__G__Gui2_251_0_20, 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("GetPos",594,G__G__Gui2_251_0_21, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedEntry",1627,G__G__Gui2_251_0_22, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedEntries",1827,G__G__Gui2_251_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - selected", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Gui2_251_0_24, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - id g - 'Bool_t' 0 - sel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Gui2_251_0_25, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVScrollbar",1306,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_TGVScrollBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVsbPosition",1452,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newPos", (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("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("SetMultipleSelections",2193,G__G__Gui2_251_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - multi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMultipleSelections",2181,G__G__Gui2_251_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_251_0_32, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLBContainer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_251_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBContainer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_251_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLBContainer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_251_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLBContainer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_251_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__Gui2_251_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBContainer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_251_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBContainer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_251_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBContainer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_251_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBContainer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLBContainer", 1354, G__G__Gui2_251_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGComboBoxPopup(void) {
   /* TGComboBoxPopup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup));
   G__memfunc_setup("TGComboBoxPopup",1480,G__G__Gui2_253_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGComboBoxPopup), -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 'kVerticalFrame' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' 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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetListBox",1009,G__G__Gui2_253_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListBox' - 0 - lb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PlacePopup",1017,G__G__Gui2_253_0_4, 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, 0);
   G__memfunc_setup("EndPopup",811,G__G__Gui2_253_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_253_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGComboBoxPopup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_253_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGComboBoxPopup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_253_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGComboBoxPopup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_253_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGComboBoxPopup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_253_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__Gui2_253_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGComboBoxPopup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_253_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGComboBoxPopup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_253_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGComboBoxPopup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_253_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGComboBoxPopup::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGComboBoxPopup", 1606, G__G__Gui2_253_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGComboBox(void) {
   /* TGComboBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox));
   G__memfunc_setup("TGComboBox",948,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox), -1, 0, 1, 1, 4, 0, "u 'TGComboBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox), -1, 1, 1, 1, 4, 0, "u 'TGComboBox' - 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, 1);
   G__memfunc_setup("TGComboBox",948,G__G__Gui2_254_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame|kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGComboBox",948,G__G__Gui2_254_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGComboBox), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - text "
"i - 'Int_t' 0 '-1' id h - 'UInt_t' 0 'kHorizontalFrame|kSunkenFrame|kDoubleBorder' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' 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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_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("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("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("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("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("AddEntry",795,G__G__Gui2_254_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGString' - 0 - s i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntry",795,G__G__Gui2_254_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddEntry",795,G__G__Gui2_254_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_254_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGString' - 0 - s i - 'Int_t' 0 - id "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_254_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - id "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertEntry",1159,G__G__Gui2_254_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGLBEntry' - 0 - lbe U 'TGLayoutHints' - 0 - lhints "
"i - 'Int_t' 0 - afterID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewEntry",828,G__G__Gui2_254_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"Entry\"' s", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemoveEntry",1152,G__G__Gui2_254_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' id", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemoveAll",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (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("IsTextInputEnabled",1820,G__G__Gui2_254_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableTextInput",1532,G__G__Gui2_254_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", "*TOGGLE* *GETTER=IsTextInputEnabled", (void*) NULL, 1);
   G__memfunc_setup("RemoveEntries",1352,G__G__Gui2_254_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - from_ID i - 'Int_t' 0 - to_ID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberOfEntries",1816,G__G__Gui2_254_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListBox",997,G__G__Gui2_254_0_28, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListBox), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextEntry",1239,G__G__Gui2_254_0_29, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEntry), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindEntry",915,G__G__Gui2_254_0_30, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 1, 1, 1, 8, "C - - 10 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Gui2_254_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - id g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelected",1097,G__G__Gui2_254_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedEntry",1627,G__G__Gui2_254_0_33, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGLBEntry), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTopEntry",1137,G__G__Gui2_254_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLBEntry' - 0 - e U 'TGLayoutHints' - 0 - lh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEnabled",983,G__G__Gui2_254_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "*TOGGLE* *GETTER=IsEnabled", (void*) NULL, 1);
   G__memfunc_setup("IsEnabled",871,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SortByName",996,G__G__Gui2_254_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ascend", "*MENU*icon=bld_sortup.png*", (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_254_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - widgetId i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_254_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_254_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - txt", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,G__G__Gui2_254_0_41, 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__Gui2_254_0_43, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGComboBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_254_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGComboBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_254_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGComboBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_254_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGComboBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_254_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__Gui2_254_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGComboBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_254_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGComboBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_254_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGComboBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_254_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGComboBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGComboBox", 1074, G__G__Gui2_254_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLineStyleComboBox(void) {
   /* TGLineStyleComboBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox));
   G__memfunc_setup("TGLineStyleComboBox",1869,G__G__Gui2_255_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLineStyleComboBox), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame|kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetWhitePixel()' 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__Gui2_255_0_3, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLineStyleComboBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_255_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineStyleComboBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_255_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLineStyleComboBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_255_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLineStyleComboBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_255_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__Gui2_255_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineStyleComboBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_255_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLineStyleComboBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_255_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineStyleComboBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_255_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLineStyleComboBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLineStyleComboBox", 1995, G__G__Gui2_255_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLineWidthComboBox(void) {
   /* TGLineWidthComboBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox));
   G__memfunc_setup("TGLineWidthComboBox",1852,G__G__Gui2_256_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLineWidthComboBox), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame|kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetWhitePixel()' back "
"g - 'Bool_t' 0 'kFALSE' none", (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__Gui2_256_0_3, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLineWidthComboBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_256_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineWidthComboBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_256_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLineWidthComboBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_256_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLineWidthComboBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_256_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__Gui2_256_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineWidthComboBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_256_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLineWidthComboBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_256_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLineWidthComboBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_256_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLineWidthComboBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLineWidthComboBox", 1978, G__G__Gui2_256_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFontTypeComboBox(void) {
   /* TGFontTypeComboBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox));
   G__memfunc_setup("TGFontTypeComboBox",1773,G__G__Gui2_257_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFontTypeComboBox), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame|kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetWhitePixel()' bask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_257_0_2, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFontTypeComboBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_257_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontTypeComboBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_257_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFontTypeComboBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_257_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFontTypeComboBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_257_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_257_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontTypeComboBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_257_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFontTypeComboBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_257_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFontTypeComboBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_257_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFontTypeComboBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFontTypeComboBox", 1899, G__G__Gui2_257_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTabElement(void) {
   /* TGTabElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement));
   G__memfunc_setup("TGTabElement",1148,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement), -1, 0, 1, 1, 4, 0, "u 'TGTabElement' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement), -1, 1, 1, 1, 4, 0, "u 'TGTabElement' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGTabElement",1148,G__G__Gui2_258_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGString' - 0 '0' text "
"h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h "
"k - 'GContext_t' 0 'TGTab::GetDefaultGC()()' norm k - 'FontStruct_t' 0 'TGTab::GetDefaultFontStruct()' font "
"h - 'UInt_t' 0 'kRaisedFrame' 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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,G__G__Gui2_258_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetString",919,G__G__Gui2_258_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (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("SetText",721,G__G__Gui2_258_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGString' - 0 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnabled",983,G__G__Gui2_258_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEnabled",871,G__G__Gui2_258_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditDisabled",1482,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowClose",919,G__G__Gui2_258_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCloseShown",1217,G__G__Gui2_258_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActive",904,G__G__Gui2_258_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_258_0_17, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTabElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_258_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTabElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_258_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTabElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_258_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTabElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_258_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__Gui2_258_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTabElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_258_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTabElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_258_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTabElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_258_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTabElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTabElement", 1274, G__G__Gui2_258_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTab(void) {
   /* TGTab */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTab));
   G__memfunc_setup("ChangeTab",861,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - tabIndex g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTab",434,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTab), -1, 0, 1, 1, 4, 0, "u 'TGTab' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTab), -1, 1, 1, 1, 4, 0, "u 'TGTab' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui2_259_0_4, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGTab::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui2_259_0_5, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGTab::GetDefaultGC) ), 0);
   G__memfunc_setup("TGTab",434,G__G__Gui2_259_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTab), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h 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("AddTab",544,G__G__Gui2_259_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 1, 1, 1, 0, "U 'TGString' - 0 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTab",544,G__G__Gui2_259_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTab",544,G__G__Gui2_259_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text U 'TGCompositeFrame' - 0 - cf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTab",544,G__G__Gui2_259_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGString' - 0 - text U 'TGCompositeFrame' - 0 - cf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewTab",577,G__G__Gui2_259_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"tab\"' text", "*MENU*icon=bld_newtab.png*", (void*) NULL, 1);
   G__memfunc_setup("RemoveTab",901,G__G__Gui2_259_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '-1' tabIndex g - 'Bool_t' 0 'kTRUE' storeRemoved", "*MENU*icon=bld_removetab.png*", (void*) NULL, 1);
   G__memfunc_setup("SetTab",579,G__G__Gui2_259_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - tabIndex g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTab",579,G__G__Gui2_259_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kTRUE' emit", (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("GetContainer",1219,G__G__Gui2_259_0_16, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrent",1027,G__G__Gui2_259_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabContainer",1498,G__G__Gui2_259_0_18, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - tabIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabContainer",1498,G__G__Gui2_259_0_19, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabTab",846,G__G__Gui2_259_0_20, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - tabIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabTab",846,G__G__Gui2_259_0_21, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentContainer",1958,G__G__Gui2_259_0_22, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentTab",1306,G__G__Gui2_259_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTabElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTabHeight",1168,G__G__Gui2_259_0_24, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfTabs",1480,G__G__Gui2_259_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnabled",983,G__G__Gui2_259_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - tabIndex g - 'Bool_t' 0 'kTRUE' on", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui2_259_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"tab\"' text", "*MENU*icon=bld_rename.png*", (void*) NULL, 1);
   G__memfunc_setup("IsEnabled",871,G__G__Gui2_259_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - tabIndex", (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("CloseTab",781,G__G__Gui2_259_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Removed",722,G__G__Gui2_259_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Selected",809,G__G__Gui2_259_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetLayoutManager",1625,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_TGLayoutManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_259_0_34, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTab::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_259_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTab::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_259_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTab::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_259_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTab::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_259_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__Gui2_259_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTab::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_259_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTab::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_259_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTab::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_259_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTab::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTab", 560, G__G__Gui2_259_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTabLayout(void) {
   /* TGTabLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout));
   G__memfunc_setup("TGTabLayout",1072,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout), -1, 0, 1, 1, 4, 0, "u 'TGTabLayout' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout), -1, 1, 1, 1, 4, 0, "u 'TGTabLayout' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGTabLayout",1072,G__G__Gui2_260_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTabLayout), -1, 0, 1, 1, 1, 0, "U 'TGTab' - 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__Gui2LN_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__Gui2_260_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTabLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_260_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTabLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_260_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTabLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_260_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTabLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_260_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__Gui2_260_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTabLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_260_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTabLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_260_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTabLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_260_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTabLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTabLayout", 1198, G__G__Gui2_260_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSlider(void) {
   /* TGSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSlider));
   G__memfunc_setup("GetTypeString",1337,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TString), -1, 0, 0, 1, 2, 8, "", "used in SavePrimitive", (void*) NULL, 0);
   G__memfunc_setup("CreateDisabledPicture",2120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGSlider), -1, 1, 1, 1, 4, 0, "u 'TGSlider' - 11 - -", "not implemented", (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, 3);
   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, 3);
   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, 3);
   G__memfunc_setup("SetEnabled",983,G__G__Gui2_263_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsEnabled", (void*) NULL, 1);
   G__memfunc_setup("SetState",813,G__G__Gui2_263_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScale",788,G__G__Gui2_263_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - scale", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Gui2_263_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,G__G__Gui2_263_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetPosition",1141,G__G__Gui2_263_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinPosition",1433,G__G__Gui2_263_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxPosition",1435,G__G__Gui2_263_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,G__G__Gui2_263_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (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("ChangeSliderPic",1477,G__G__Gui2_263_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PositionChanged",1535,G__G__Gui2_263_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Pressed",726,G__G__Gui2_263_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Released",805,G__G__Gui2_263_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_263_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_263_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_263_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_263_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_263_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__Gui2_263_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_263_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_263_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_263_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSlider", 892, G__G__Gui2_263_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVSlider(void) {
   /* TGVSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGVSlider",852,G__G__Gui2_264_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGVSlider), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '40' h "
"h - 'UInt_t' 0 'kSlider1|kScaleBoth' type i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kVerticalFrame' 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("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("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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 - w h - 'UInt_t' 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("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__Gui2_264_0_10, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_264_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_264_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_264_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_264_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_264_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_264_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_264_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_264_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVSlider", 978, G__G__Gui2_264_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHSlider(void) {
   /* TGHSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGHSlider",838,G__G__Gui2_265_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGHSlider), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '40' w "
"h - 'UInt_t' 0 'kSlider1|kScaleBoth' type i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame' 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("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("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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (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 - w h - 'UInt_t' 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("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__Gui2_265_0_10, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_265_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_265_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_265_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_265_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_265_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_265_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_265_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_265_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHSlider", 964, G__G__Gui2_265_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSplitter(void) {
   /* TGSplitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGSplitter), -1, 1, 1, 1, 4, 0, "u 'TGSplitter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetFrame",791,G__G__Gui2_267_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - frame g - 'Bool_t' 0 - prev", (char*)NULL, (void*) NULL, 3);
   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, 3);
   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, 3);
   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, 3);
   G__memfunc_setup("DragStarted",1109,G__G__Gui2_267_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Moved",507,G__G__Gui2_267_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - delta", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("GetExternalHandler",1825,G__G__Gui2_267_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExternalHandler",1837,G__G__Gui2_267_0_11, 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__Gui2_267_0_12, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSplitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_267_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_267_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSplitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_267_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSplitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_267_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__Gui2_267_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_267_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_267_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSplitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_267_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSplitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSplitter", 1136, G__G__Gui2_267_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGVSplitter(void) {
   /* TGVSplitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter));
   G__memfunc_setup("TGVSplitter",1096,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter), -1, 0, 1, 1, 4, 0, "u 'TGVSplitter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter), -1, 1, 1, 1, 4, 0, "u 'TGVSplitter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGVSplitter",1096,G__G__Gui2_268_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '4' 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("TGVSplitter",1096,G__G__Gui2_268_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGVSplitter), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h g - 'Bool_t' 0 - external", (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("SetFrame",791,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - frame g - 'Bool_t' 0 - left", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFrame",779,G__G__Gui2_268_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeft",683,G__G__Gui2_268_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLeft",583,G__G__Gui2_268_0_9, 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("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("Class",502,G__G__Gui2_268_0_14, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGVSplitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_268_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVSplitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_268_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGVSplitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_268_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGVSplitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_268_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__Gui2_268_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVSplitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_268_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVSplitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_268_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGVSplitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_268_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGVSplitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGVSplitter", 1222, G__G__Gui2_268_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGHSplitter(void) {
   /* TGHSplitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter));
   G__memfunc_setup("TGHSplitter",1082,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter), -1, 0, 1, 1, 4, 0, "u 'TGHSplitter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter), -1, 1, 1, 1, 4, 0, "u 'TGHSplitter' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGHSplitter",1082,G__G__Gui2_269_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '4' 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("TGHSplitter",1082,G__G__Gui2_269_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGHSplitter), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h g - 'Bool_t' 0 - external", (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("SetFrame",791,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGFrame' - 0 - frame g - 'Bool_t' 0 - above", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFrame",779,G__G__Gui2_269_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFrame), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAbove",781,G__G__Gui2_269_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAbove",681,G__G__Gui2_269_0_9, 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("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("Class",502,G__G__Gui2_269_0_14, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGHSplitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_269_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHSplitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_269_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGHSplitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_269_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGHSplitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_269_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__Gui2_269_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHSplitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_269_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHSplitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_269_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGHSplitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_269_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGHSplitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGHSplitter", 1208, G__G__Gui2_269_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLVContainer(void) {
   /* TGLVContainer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer));
   G__memfunc_setup("TGLVContainer",1248,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer), -1, 0, 1, 1, 4, 0, "u 'TGLVContainer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer), -1, 1, 1, 1, 4, 0, "u 'TGLVContainer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ActivateItem",1216,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrameElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeActivateItem",1385,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrameElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLVContainer",1248,G__G__Gui2_271_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h h - 'UInt_t' 0 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVContainer",1248,G__G__Gui2_271_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLVContainer), -1, 0, 3, 1, 1, 0, 
"U 'TGCanvas' - 0 - p h - 'UInt_t' 0 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListView",1111,G__G__Gui2_271_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListView), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddItem",664,G__G__Gui2_271_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLVEntry' - 0 - item", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetListView",1123,G__G__Gui2_271_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListView' - 0 - lv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveItemWithData",1811,G__G__Gui2_271_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - userData", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetViewMode",1100,G__G__Gui2_271_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EListViewMode' - 0 - viewMode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetViewMode",1088,G__G__Gui2_271_0_12, 105, G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColumns",1037,G__G__Gui2_271_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - cpos I - 'Int_t' 0 - jmode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPageDimension",1603,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxItemSize",1392,G__G__Gui2_271_0_15, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxSubnameWidth",1809,G__G__Gui2_271_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColHeaders",1286,G__G__Gui2_271_0_17, 121, -1, -1, 0, 12, 1, 1, 0, 
"C - - 10 '\"\"' n1 C - - 10 '\"\"' n2 "
"C - - 10 '\"\"' n3 C - - 10 '\"\"' n4 "
"C - - 10 '\"\"' n5 C - - 10 '\"\"' n6 "
"C - - 10 '\"\"' n7 C - - 10 '\"\"' n8 "
"C - - 10 '\"\"' n9 C - - 10 '\"\"' n10 "
"C - - 10 '\"\"' n11 C - - 10 '\"\"' n12", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineUp",589,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineDown",800,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineLeft",787,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineRight",902,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (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("GetSelectedItems",1611,G__G__Gui2_271_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMultipleSelection",2066,G__G__Gui2_271_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMultipleSelection",2078,G__G__Gui2_271_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' multi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHeaders",1000,G__G__Gui2_271_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ncolumns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHeader",885,G__G__Gui2_271_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - s i - 'Int_t' 0 - hmode "
"i - 'Int_t' 0 - cmode i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultHeaders",1709,G__G__Gui2_271_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeader",873,G__G__Gui2_271_0_29, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - idx", (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__Gui2_271_0_31, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLVContainer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_271_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVContainer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_271_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLVContainer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_271_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLVContainer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_271_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_271_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVContainer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_271_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVContainer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_271_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVContainer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_271_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVContainer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLVContainer", 1374, G__G__Gui2_271_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLVEntry(void) {
   /* TGLVEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry));
   G__memfunc_setup("TGLVEntry",847,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry), -1, 0, 1, 1, 4, 0, "u 'TGLVEntry' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry), -1, 1, 1, 1, 4, 0, "u 'TGLVEntry' - 11 - -", "Not implemented", (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("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("GetDefaultGC",1135,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVEntry",847,G__G__Gui2_272_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGPicture' - 10 '0' bigpic "
"U 'TGPicture' - 10 '0' smallpic U 'TGString' - 0 '0' name "
"U 'TGString' - 2 '0' subnames i 'EListViewMode' - 0 'kLVDetails' ViewMode "
"h - 'UInt_t' 0 'kChildFrame' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVEntry",847,G__G__Gui2_272_0_7, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGLVEntry), -1, 0, 6, 1, 1, 0, 
"U 'TGLVContainer' - 10 - p u 'TString' - 11 - name "
"u 'TString' - 11 - cname U 'TGString' - 2 '0' subnames "
"h - 'UInt_t' 0 'kChildFrame' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewMode",1100,G__G__Gui2_272_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EListViewMode' - 0 - viewMode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Activate",817,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetItemName",1072,G__G__Gui2_272_0_11, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGString), -1, 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("SetTitle",814,G__G__Gui2_272_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetItemName",1084,G__G__Gui2_272_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui2_272_0_15, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewMode",1088,G__G__Gui2_272_0_16, 105, G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUserData",1093,G__G__Gui2_272_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - userData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserData",1081,G__G__Gui2_272_0_18, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubnames",1130,G__G__Gui2_272_0_19, 121, -1, -1, 0, 12, 1, 1, 0, 
"C - - 10 '\"\"' n1 C - - 10 '\"\"' n2 "
"C - - 10 '\"\"' n3 C - - 10 '\"\"' n4 "
"C - - 10 '\"\"' n5 C - - 10 '\"\"' n6 "
"C - - 10 '\"\"' n7 C - - 10 '\"\"' n8 "
"C - - 10 '\"\"' n9 C - - 10 '\"\"' n10 "
"C - - 10 '\"\"' n11 C - - 10 '\"\"' n12", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPictures",1147,G__G__Gui2_272_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 '0' bigpic U 'TGPicture' - 10 '0' smallpic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColumns",1037,G__G__Gui2_272_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - cpos I - 'Int_t' 0 - jmode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCheckedEntry",1509,G__G__Gui2_272_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' check", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSubnameWidth",1515,G__G__Gui2_272_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_272_0_26, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLVEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_272_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_272_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLVEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_272_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLVEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_272_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_272_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_272_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_272_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_272_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLVEntry", 973, G__G__Gui2_272_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFileContainer(void) {
   /* TGFileContainer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer));
   G__memfunc_setup("CreateFileList",1392,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFileContainer",1470,G__G__Gui2_290_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer), -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 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFileContainer",1470,G__G__Gui2_290_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileContainer), -1, 0, 3, 1, 1, 0, 
"U 'TGCanvas' - 0 - p h - 'UInt_t' 0 'kSunkenFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   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("StopRefreshTimer",1654,G__G__Gui2_290_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartRefreshTimer",1758,G__G__Gui2_290_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 '1000' msec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFile",649,G__G__Gui2_290_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'TGPicture' - 10 '0' pic "
"U 'TGPicture' - 10 '0' lpic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddRemoteFile",1269,G__G__Gui2_290_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj U 'TGPicture' - 10 '0' ipic "
"U 'TGPicture' - 10 '0' ilpic", (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("Sort",424,G__G__Gui2_290_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EFSSortMode' - 0 - sortType", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFilter",914,G__G__Gui2_290_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - filter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeDirectory",1531,G__G__Gui2_290_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisplayDirectory",1675,G__G__Gui2_290_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDisplayStat",1438,G__G__Gui2_290_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' stat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDisplayStat",1426,G__G__Gui2_290_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectory",1237,G__G__Gui2_290_0_16, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFilePictures",1519,G__G__Gui2_290_0_17, 121, -1, -1, 0, 6, 1, 1, 0, 
"U 'TGPicture' - 12 - pic U 'TGPicture' - 12 - lpic "
"i - 'Int_t' 0 - file_type g - 'Bool_t' 0 - is_link "
"C - - 10 - ext g - 'Bool_t' 0 - small", (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__Gui2_290_0_19, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFileContainer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_290_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileContainer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_290_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFileContainer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_290_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFileContainer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_290_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__Gui2_290_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileContainer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_290_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileContainer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_290_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileContainer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_290_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileContainer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFileContainer", 1596, G__G__Gui2_290_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFileItem(void) {
   /* TGFileItem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"U 'TGPicture' - 10 - blpic U 'TGPicture' - 10 - slpic "
"u 'FileStat_t' - 1 - stat i 'EListViewMode' - 0 - viewMode", (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("TGFileItem",938,G__G__Gui2_293_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem), -1, 0, 14, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGPicture' - 10 '0' bpic "
"U 'TGPicture' - 10 '0' blpic U 'TGPicture' - 10 '0' spic "
"U 'TGPicture' - 10 '0' slpic U 'TGString' - 0 '0' name "
"i - 'Int_t' 0 '0' type n - 'Long64_t' 0 '1' size "
"i - 'Int_t' 0 '0' uid i - 'Int_t' 0 '0' gid "
"l - 'Long_t' 0 '0' modtime i 'EListViewMode' - 0 'kLVList' viewMode "
"h - 'UInt_t' 0 'kVerticalFrame' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGFileItem",938,G__G__Gui2_293_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileItem), -1, 0, 10, 1, 1, 0, 
"U 'TGWindow' - 10 - p U 'TGPicture' - 10 - bpic "
"U 'TGPicture' - 10 - blpic U 'TGPicture' - 10 - spic "
"U 'TGPicture' - 10 - slpic U 'TGString' - 0 - name "
"u 'FileStat_t' - 1 - stat i 'EListViewMode' - 0 'kLVList' viewMode "
"h - 'UInt_t' 0 'kVerticalFrame' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewMode",1100,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i 'EListViewMode' - 0 - viewMode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymLink",899,G__G__Gui2_293_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Gui2_293_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Gui2_293_0_9, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetModTime",975,G__G__Gui2_293_0_10, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUid",578,G__G__Gui2_293_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGid",564,G__G__Gui2_293_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDNDdata",912,G__G__Gui2_293_0_13, 85, G__get_linked_tagnum(&G__G__Gui2LN_TDNDData), -1, 0, 1, 1, 1, 0, "k - 'Atom_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDEnter",1312,(G__InterfaceMethod) NULL,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__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDPosition",1655,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 5, 1, 1, 0, 
"i - - 0 - - i - - 0 - - "
"k - 'Atom_t' 0 - action i - - 0 - - "
"i - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDFinished",1612,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDNDData",892,G__G__Gui2_293_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDNDData' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDNDObject",1113,G__G__Gui2_293_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_293_0_20, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFileItem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_293_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileItem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_293_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFileItem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_293_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFileItem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_293_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_293_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileItem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_293_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileItem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_293_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileItem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_293_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileItem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFileItem", 1064, G__G__Gui2_293_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFSComboBox(void) {
   /* TGFSComboBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox));
   G__memfunc_setup("TGFSComboBox",1101,G__G__Gui2_298_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFSComboBox), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame|kSunkenFrame|kDoubleBorder' options k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Gui2_298_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (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__Gui2_298_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFSComboBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_298_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFSComboBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_298_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFSComboBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_298_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFSComboBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_298_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__Gui2_298_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFSComboBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_298_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFSComboBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_298_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFSComboBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_298_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFSComboBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFSComboBox", 1227, G__G__Gui2_298_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFileInfo(void) {
   /* TGFileInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo));
   G__memfunc_setup("TGFileInfo",935,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo), -1, 0, 1, 1, 4, 0, "u 'TGFileInfo' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo), -1, 1, 1, 1, 4, 0, "u 'TGFileInfo' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGFileInfo",935,G__G__Gui2_299_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMultipleSelection",2078,G__G__Gui2_299_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - option", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGFileInfo", 1061, G__G__Gui2_299_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGFileDialog(void) {
   /* TGFileDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog));
   G__memfunc_setup("TGFileDialog",1131,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog), -1, 0, 1, 1, 4, 0, "u 'TGFileDialog' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog), -1, 1, 1, 1, 4, 0, "u 'TGFileDialog' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGFileDialog",1131,G__G__Gui2_300_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGFileDialog), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGWindow' - 10 '0' main "
"i 'EFileDialogMode' - 0 'kFDOpen' dlg_type U 'TGFileInfo' - 0 '0' file_info", (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 - parm2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_300_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGFileDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_300_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_300_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGFileDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_300_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGFileDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_300_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__Gui2_300_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_300_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_300_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGFileDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_300_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGFileDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGFileDialog", 1257, G__G__Gui2_300_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGStatusBar(void) {
   /* TGStatusBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar));
   G__memfunc_setup("TGStatusBar",1076,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar), -1, 0, 1, 1, 4, 0, "u 'TGStatusBar' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar), -1, 1, 1, 1, 4, 0, "u 'TGStatusBar' - 11 - -", "not implemented", (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("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("GetDefaultGC",1135,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGStatusBar",1076,G__G__Gui2_302_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGStatusBar), -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 'kSunkenFrame|kHorizontalFrame' 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("SetText",721,G__G__Gui2_302_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGString' - 0 - text i - 'Int_t' 0 '0' partidx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui2_302_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text i - 'Int_t' 0 '0' partidx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddText",686,G__G__Gui2_302_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text i - 'Int_t' 0 '0' partidx", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui2_302_0_11, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 '0' partidx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParts",822,G__G__Gui2_302_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npart", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetParts",822,G__G__Gui2_302_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - parts i - 'Int_t' 0 - npart", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw3DCorner",1134,G__G__Gui2_302_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - corner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBarPart",972,G__G__Gui2_302_0_15, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGCompositeFrame), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - npart", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_302_0_18, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGStatusBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_302_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGStatusBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_302_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGStatusBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_302_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGStatusBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_302_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__Gui2_302_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGStatusBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_302_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGStatusBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_302_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGStatusBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_302_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGStatusBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGStatusBar", 1202, G__G__Gui2_302_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncToolBarData_t(void) {
   /* ToolBarData_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_ToolBarData_t));
   // automatic default constructor
   G__memfunc_setup("ToolBarData_t", 1280, G__G__Gui2_307_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_ToolBarData_t), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ToolBarData_t", 1280, G__G__Gui2_307_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_ToolBarData_t), -1, 0, 1, 1, 1, 0, "u 'ToolBarData_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ToolBarData_t", 1406, G__G__Gui2_307_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGToolBar(void) {
   /* TGToolBar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar));
   G__memfunc_setup("TGToolBar",846,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar), -1, 0, 1, 1, 4, 0, "u 'TGToolBar' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar), -1, 1, 1, 1, 4, 0, "u 'TGToolBar' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGToolBar",846,G__G__Gui2_308_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGToolBar), -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 'kHorizontalFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddButton",901,G__G__Gui2_308_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGButton), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - w U 'ToolBarData_t' - 0 - button "
"i - 'Int_t' 0 '0' spacing", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddButton",901,G__G__Gui2_308_0_5, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGButton), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - w U 'TGPictureButton' - 0 - button "
"i - 'Int_t' 0 '0' spacing", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ChangeIcon",975,G__G__Gui2_308_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'ToolBarData_t' - 0 - button C - - 10 - new_icon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cleanup",712,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetButton",924,G__G__Gui2_308_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGButton), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetId",461,G__G__Gui2_308_0_9, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "U 'TGButton' - 0 - button", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetId",473,G__G__Gui2_308_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGButton' - 0 - button l - 'Long_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ButtonPressed",1362,G__G__Gui2_308_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ButtonReleased",1441,G__G__Gui2_308_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ButtonClicked",1323,G__G__Gui2_308_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pressed",726,G__G__Gui2_308_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Released",805,G__G__Gui2_308_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_308_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*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__Gui2_308_0_18, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGToolBar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_308_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGToolBar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_308_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGToolBar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_308_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGToolBar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_308_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__Gui2_308_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGToolBar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_308_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGToolBar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_308_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGToolBar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_308_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGToolBar::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGToolBar", 972, G__G__Gui2_308_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListTreeItem(void) {
   /* TGListTreeItem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 1, 1, 1, 4, 0, "u 'TGListTreeItem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Gui2_309_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstChild",1292,G__G__Gui2_309_0_5, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastChild",1176,G__G__Gui2_309_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrevSibling",1413,G__G__Gui2_309_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextSibling",1415,G__G__Gui2_309_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOpen",590,G__G__Gui2_309_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOpen",702,G__G__Gui2_309_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,G__G__Gui2_309_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetActiveColor",1403,G__G__Gui2_309_0_12, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetActive",904,G__G__Gui2_309_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rename",600,G__G__Gui2_309_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - new_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui2_309_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTextLength",1319,G__G__Gui2_309_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTipText",1010,G__G__Gui2_309_0_17, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTipTextLength",1620,G__G__Gui2_309_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetText",721,G__G__Gui2_309_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTipText",1022,G__G__Gui2_309_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUserData",1093,G__G__Gui2_309_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserData",1081,G__G__Gui2_309_0_22, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPicture",1020,G__G__Gui2_309_0_23, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPictures",1147,G__G__Gui2_309_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 - - U 'TGPicture' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckBoxPicture",1795,G__G__Gui2_309_0_25, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCheckBoxPictures",1922,G__G__Gui2_309_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 - - U 'TGPicture' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPicWidth",1084,G__G__Gui2_309_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCheckBox",1075,G__G__Gui2_309_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCheckBox",1059,G__G__Gui2_309_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckItem",877,G__G__Gui2_309_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Toggle",610,G__G__Gui2_309_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsChecked",867,G__G__Gui2_309_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckAllChildren",1568,G__G__Gui2_309_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckChildren",1287,G__G__Gui2_309_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - - g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCheckedChild",1447,G__G__Gui2_309_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", "!!!!", (void*) NULL, 1);
   G__memfunc_setup("HasUnCheckedChild",1642,G__G__Gui2_309_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' -", "!!!!", (void*) NULL, 1);
   G__memfunc_setup("UpdateState",1124,G__G__Gui2_309_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasColor",795,G__G__Gui2_309_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColor",799,G__G__Gui2_309_0_39, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetColor",811,G__G__Gui2_309_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearColor",998,G__G__Gui2_309_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDNDSource",1139,G__G__Gui2_309_0_42, 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__Gui2_309_0_43, 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__Gui2_309_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDNDTarget",1017,G__G__Gui2_309_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandlesDragAndDrop",1765,G__G__Gui2_309_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDrag",970,G__G__Gui2_309_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDrop",993,G__G__Gui2_309_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Gui2_309_0_49, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - C - 'Option_t' 10 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_309_0_50, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListTreeItem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_309_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTreeItem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_309_0_52, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListTreeItem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_309_0_53, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListTreeItem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui2_309_0_54, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui2_309_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui2_309_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui2_309_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_309_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTreeItem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_309_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListTreeItem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_309_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTreeItem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_309_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListTreeItem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListTreeItem", 1492, G__G__Gui2_309_0_62, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListTree(void) {
   /* TGListTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTree));
   G__memfunc_setup("GetGrayPixel",1205,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   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("GetDrawGC",824,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineGC",818,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHighlightGC",1346,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColorGC",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - yevent "
"i - 'Int_t' 0 - hevent", (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("DrawChildren",1207,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"k - 'Handle_t' 0 - id U 'TGListTreeItem' - 0 - item "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - xroot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawItem",797,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"k - 'Handle_t' 0 - id U 'TGListTreeItem' - 0 - item "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"I - 'Int_t' 0 - xroot H - 'UInt_t' 0 - retwidth "
"H - 'UInt_t' 0 - retheight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawItemName",1182,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"k - 'Handle_t' 0 - id U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawNode",788,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"k - 'Handle_t' 0 - id U 'TGListTreeItem' - 0 - item "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateChecked",1290,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 'kFALSE' redraw", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveChildren",1208,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out U 'TGListTreeItem' - 0 - item "
"i - 'Int_t' 1 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveReference",1533,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDeleteItem",1074,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDeleteChildren",1484,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertChild",1113,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGListTreeItem' - 0 - parent U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertChildren",1438,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGListTreeItem' - 0 - parent U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchChildren",1407,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - findy U 'TGListTreeItem' - 2 - finditem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindItem",784,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - findy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindItem",784,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 4, 1, 2, 0, 
"u 'TString' - 11 - name g - 'Bool_t' 0 'kTRUE' direction "
"g - 'Bool_t' 0 'kTRUE' caseSensitive g - 'Bool_t' 0 'kFALSE' beginWith", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Layout",638,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OnMouseOver",1122,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CurrentChanged",1421,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CurrentChanged",1421,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGFrame' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGFrame' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"U 'TGFrame' - 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TGFrame' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"U 'TGFrame' - 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeyPressed",1023,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TGFrame' - 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGListTree",967,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTree), -1, 0, 1, 1, 4, 0, "u 'TGListTree' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGListTree), -1, 1, 1, 1, 4, 0, "u 'TGListTree' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGListTree",967,G__G__Gui2_310_0_35, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTree), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 0 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGListTree",967,G__G__Gui2_310_0_36, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTree), -1, 0, 3, 1, 1, 0, 
"U 'TGCanvas' - 0 - p h - 'UInt_t' 0 - options "
"k - 'Pixel_t' 0 'GetWhitePixel()' 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("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("SetCanvas",904,G__G__Gui2_310_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGCanvas' - 0 - canvas", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawRegion",1010,(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 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawOutline",1134,G__G__Gui2_310_0_44, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'Handle_t' 0 - id U 'TGListTreeItem' - 0 - item "
"k - 'Pixel_t' 0 '0xbbbbbb' col g - 'Bool_t' 0 'kFALSE' clear", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawActive",1002,G__G__Gui2_310_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'Handle_t' 0 - id U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddItem",664,G__G__Gui2_310_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - parent U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddItem",664,G__G__Gui2_310_0_48, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 5, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - parent C - - 10 - string "
"U 'TGPicture' - 10 '0' open U 'TGPicture' - 10 '0' closed "
"g - 'Bool_t' 0 'kFALSE' checkbox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddItem",664,G__G__Gui2_310_0_49, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 6, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - parent C - - 10 - string "
"Y - - 0 - userData U 'TGPicture' - 10 '0' open "
"U 'TGPicture' - 10 '0' closed g - 'Bool_t' 0 'kFALSE' checkbox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenameItem",999,G__G__Gui2_310_0_50, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteItem",994,G__G__Gui2_310_0_51, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenItem",801,G__G__Gui2_310_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseItem",901,G__G__Gui2_310_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckItem",877,G__G__Gui2_310_0_54, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 'kTRUE' check", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCheckBox",1075,G__G__Gui2_310_0_55, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleItem",1009,G__G__Gui2_310_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecursiveDeleteItem",1946,G__G__Gui2_310_0_57, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item Y - - 0 - userData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteChildren",1404,G__G__Gui2_310_0_58, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reparent",833,G__G__Gui2_310_0_59, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item U 'TGListTreeItem' - 0 - newparent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReparentChildren",1642,G__G__Gui2_310_0_60, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item U 'TGListTreeItem' - 0 - newparent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToolTipItem",1414,G__G__Gui2_310_0_61, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoTips",1125,G__G__Gui2_310_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoCheckBoxPic",1768,G__G__Gui2_310_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelected",1109,G__G__Gui2_310_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustPosition",1472,G__G__Gui2_310_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustPosition",1472,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Home",393,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("End",279,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PageUp",578,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PageDown",789,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineUp",589,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineDown",800,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' select", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Search",598,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' close", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Gui2_310_0_74, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortSiblings",1251,G__G__Gui2_310_0_75, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortChildren",1233,G__G__Gui2_310_0_76, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighlightItem",1319,G__G__Gui2_310_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearHighlighted",1608,G__G__Gui2_310_0_78, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPathnameFromItem",1905,G__G__Gui2_310_0_79, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item C - - 0 - path "
"i - 'Int_t' 0 '0' depth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnselectAll",1116,G__G__Gui2_310_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - draw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToolTipText",1436,G__G__Gui2_310_0_81, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - text i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y l - 'Long_t' 0 - delayms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighlightItem",1319,G__G__Gui2_310_0_82, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 - state "
"g - 'Bool_t' 0 - draw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighlightChildren",1729,G__G__Gui2_310_0_83, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 - state "
"g - 'Bool_t' 0 - draw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableOpen",1094,G__G__Gui2_310_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' disable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChecked",967,G__G__Gui2_310_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - checked", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheckedChildren",1776,G__G__Gui2_310_0_86, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TList' - 0 - checked U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckAllChildren",1568,G__G__Gui2_310_0_87, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstItem",1207,G__G__Gui2_310_0_88, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelected",1097,G__G__Gui2_310_0_89, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrent",1027,G__G__Gui2_310_0_90, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBelowMouse",1314,G__G__Gui2_310_0_91, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindSiblingByName",1669,G__G__Gui2_310_0_92, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindSiblingByData",1662,G__G__Gui2_310_0_93, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item Y - - 0 - userData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindChildByName",1441,G__G__Gui2_310_0_94, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindChildByData",1434,G__G__Gui2_310_0_95, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item Y - - 0 - userData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindItemByPathname",1785,G__G__Gui2_310_0_96, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindItemByObj",1254,G__G__Gui2_310_0_97, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item Y - - 0 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddItem",664,G__G__Gui2_310_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("AddRoot",685,G__G__Gui2_310_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("DeleteSelected",1404,G__G__Gui2_310_0_100, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("RenameSelected",1409,G__G__Gui2_310_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("MouseOver",933,G__G__Gui2_310_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - entry", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MouseOver",933,G__G__Gui2_310_0_103, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry h - 'UInt_t' 0 - mask", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("KeyPressed",1023,G__G__Gui2_310_0_104, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry h - 'UInt_t' 0 - keysym "
"h - 'UInt_t' 0 - mask", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReturnPressed",1366,G__G__Gui2_310_0_105, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - entry", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_310_0_106, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry i - 'Int_t' 0 - btn", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_310_0_107, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_310_0_108, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry i - 'Int_t' 0 - btn "
"h - 'UInt_t' 0 - mask i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_310_0_109, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry i - 'Int_t' 0 - btn", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_310_0_110, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry i - 'Int_t' 0 - btn "
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Checked",679,G__G__Gui2_310_0_111, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - check", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DataDropped",1096,G__G__Gui2_310_0_112, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item U 'TDNDData' - 0 - data", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("FontHeight",1008,G__G__Gui2_310_0_113, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FontAscent",1013,G__G__Gui2_310_0_114, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TextWidth",933,G__G__Gui2_310_0_115, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOpenPic",974,G__G__Gui2_310_0_116, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGPicture* (*)())(&TGListTree::GetOpenPic) ), 0);
   G__memfunc_setup("GetClosedPic",1174,G__G__Gui2_310_0_117, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGPicture* (*)())(&TGListTree::GetClosedPic) ), 0);
   G__memfunc_setup("GetCheckedPic",1251,G__G__Gui2_310_0_118, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGPicture* (*)())(&TGListTree::GetCheckedPic) ), 0);
   G__memfunc_setup("GetUncheckedPic",1478,G__G__Gui2_310_0_119, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGPicture* (*)())(&TGListTree::GetUncheckedPic) ), 0);
   G__memfunc_setup("SetUserControl",1452,G__G__Gui2_310_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' ctrl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasUserControl",1436,G__G__Gui2_310_0_121, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEventHandled",1502,G__G__Gui2_310_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' eh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEventHandled",1390,G__G__Gui2_310_0_123, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDDrop",1207,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TDNDData' - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDPosition",1655,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"k - 'Atom_t' 0 - action i - 'Int_t' 0 - xroot "
"i - 'Int_t' 0 - yroot", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDEnter",1312,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 1, 1, 1, 0, "K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDLeave",1295,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDNDData",880,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_TDNDData), -1, 0, 1, 1, 1, 0, "k - 'Atom_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColorMode",1188,G__G__Gui2_310_0_129, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLEColorMarkupMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColorMode",1200,G__G__Gui2_310_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGListTree::EColorMarkupMode' - 0 - colorMode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheckMode",1155,G__G__Gui2_310_0_131, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreecLcLECheckMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCheckMode",1167,G__G__Gui2_310_0_132, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGListTree::ECheckMode' - 0 - mode", (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__Gui2_310_0_134, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_310_0_135, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_310_0_136, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_310_0_137, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_310_0_141, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_310_0_142, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_310_0_143, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_310_0_144, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_310_0_145, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListTree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListTree", 1093, G__G__Gui2_310_0_146, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGListTreeItemStd(void) {
   /* TGListTreeItemStd */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd));
   G__memfunc_setup("TGListTreeItemStd",1665,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd), -1, 0, 1, 1, 4, 0, "u 'TGListTreeItemStd' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd), -1, 1, 1, 1, 4, 0, "u 'TGListTreeItemStd' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGListTreeItemStd",1665,G__G__Gui2_311_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGListTreeItemStd), -1, 0, 5, 1, 1, 0, 
"U 'TGClient' - 0 'gClient' fClient C - - 10 '0' name "
"U 'TGPicture' - 10 '0' opened U 'TGPicture' - 10 '0' closed "
"g - 'Bool_t' 0 'kFALSE' checkbox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActiveColor",1403,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetActive",904,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextLength",1319,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTipText",1010,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTipTextLength",1620,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 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, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTipText",1022,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - tip", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUserData",1093,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - userData g - 'Bool_t' 0 'kFALSE' own", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserData",1081,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPicture",1020,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckBoxPicture",1795,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPictures",1147,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 - opened U 'TGPicture' - 10 - closed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCheckBoxPictures",1922,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 - checked U 'TGPicture' - 10 - unchecked", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCheckBox",1075,(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("HasCheckBox",1059,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckItem",877,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' checked", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Toggle",610,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsChecked",867,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckAllChildren",1568,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckChildren",1287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCheckedChild",1447,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' first", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasUnCheckedChild",1642,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' first", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateState",1124,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasColor",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColor",799,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColor",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearColor",998,(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, 3, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 - option "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_311_0_34, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGListTreeItemStd::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_311_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTreeItemStd::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_311_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGListTreeItemStd::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_311_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGListTreeItemStd::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_311_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__Gui2_311_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTreeItemStd::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_311_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListTreeItemStd::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_311_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGListTreeItemStd::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_311_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGListTreeItemStd::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGListTreeItemStd", 1791, G__G__Gui2_311_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextLine(void) {
   /* TGTextLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine));
   G__memfunc_setup("TGTextLine",968,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine), -1, 0, 1, 1, 2, 0, "u 'TGTextLine' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine), -1, 1, 1, 1, 2, 0, "u 'TGTextLine' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextLine",968,G__G__Gui2_314_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextLine",968,G__G__Gui2_314_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine), -1, 0, 1, 1, 1, 0, "U 'TGTextLine' - 0 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextLine",968,G__G__Gui2_314_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine), -1, 0, 1, 1, 1, 0, "C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__G__Gui2_314_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineLength",1290,G__G__Gui2_314_0_7, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DelText",698,G__G__Gui2_314_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - pos k - 'ULong_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsText",719,G__G__Gui2_314_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - pos C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui2_314_0_10, 67, -1, -1, 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - pos k - 'ULong_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui2_314_0_11, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWord",700,G__G__Gui2_314_0_12, 67, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DelChar",659,G__G__Gui2_314_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsChar",680,G__G__Gui2_314_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - pos c - - 0 - character", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChar",670,G__G__Gui2_314_0_15, 99, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_314_0_16, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_314_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_314_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_314_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui2_314_0_20, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui2_314_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui2_314_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui2_314_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__Gui2_314_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_314_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_314_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_314_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextLine", 1094, G__G__Gui2_314_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGText(void) {
   /* TGText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGText));
   G__memfunc_setup("TGText",576,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGText), -1, 0, 1, 1, 2, 0, "u 'TGText' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGText), -1, 1, 1, 1, 2, 0, "u 'TGText' - 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("SetCurrentRow",1351,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "l - 'Long_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LongestLine",1124,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGText",576,G__G__Gui2_315_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGText",576,G__G__Gui2_315_0_7, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGText), -1, 0, 1, 1, 1, 0, "U 'TGText' - 0 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGText",576,G__G__Gui2_315_0_8, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGText), -1, 0, 1, 1, 1, 0, "C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__G__Gui2_315_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Load",384,G__G__Gui2_315_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - fn l - 'Long_t' 0 '0' startpos "
"l - 'Long_t' 0 '-1' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadBuffer",986,G__G__Gui2_315_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - txtbuf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Save",399,G__G__Gui2_315_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - fn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__Gui2_315_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - fn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSaved",687,G__G__Gui2_315_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFileName",1057,G__G__Gui2_315_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DelChar",659,G__G__Gui2_315_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLongPosition' - 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsChar",680,G__G__Gui2_315_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLongPosition' - 0 - pos c - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChar",670,G__G__Gui2_315_0_18, 99, -1, -1, 0, 1, 1, 1, 0, "u 'TGLongPosition' - 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DelText",698,G__G__Gui2_315_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLongPosition' - 0 - start u 'TGLongPosition' - 0 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsText",719,G__G__Gui2_315_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLongPosition' - 0 - pos C - - 10 - buf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsText",719,G__G__Gui2_315_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TGLongPosition' - 0 - ins_pos U 'TGText' - 0 - src "
"u 'TGLongPosition' - 0 - start_src u 'TGLongPosition' - 0 - end_src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddText",686,G__G__Gui2_315_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGText' - 0 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DelLine",669,G__G__Gui2_315_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLine",680,G__G__Gui2_315_0_24, 67, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLongPosition' - 0 - pos k - 'ULong_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__Gui2_315_0_25, 117, G__get_linked_tagnum(&G__G__Gui2LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentLine",1419,G__G__Gui2_315_0_26, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGTextLine), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BreakLine",877,G__G__Gui2_315_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLongPosition' - 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsLine",690,G__G__Gui2_315_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - row C - - 10 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RowCount",833,G__G__Gui2_315_0_29, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColCount",807,G__G__Gui2_315_0_30, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineLength",1290,G__G__Gui2_315_0_31, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLongestLine",1412,G__G__Gui2_315_0_32, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReTab",462,G__G__Gui2_315_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Search",598,G__G__Gui2_315_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"U 'TGLongPosition' - 0 - foundPos u 'TGLongPosition' - 0 - start "
"C - - 10 - searchString g - 'Bool_t' 0 - direction "
"g - 'Bool_t' 0 - caseSensitive", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Replace",700,G__G__Gui2_315_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"u 'TGLongPosition' - 0 - start C - - 10 - oldText "
"C - - 10 - newText g - 'Bool_t' 0 - direction "
"g - 'Bool_t' 0 - caseSensitive", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_315_0_36, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_315_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_315_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_315_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Gui2_315_0_40, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Gui2_315_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Gui2_315_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Gui2_315_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__Gui2_315_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_315_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_315_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_315_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGText::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGText", 702, G__G__Gui2_315_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGViewFrame(void) {
   /* TGViewFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame));
   G__memfunc_setup("TGViewFrame",1057,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame), -1, 0, 1, 1, 4, 0, "u 'TGViewFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame), -1, 1, 1, 1, 4, 0, "u 'TGViewFrame' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGViewFrame",1057,G__G__Gui2_325_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame), -1, 0, 5, 1, 1, 0, 
"U 'TGView' - 0 - v h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h h - 'UInt_t' 0 '0' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   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("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("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("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("HandleExpose",1216,(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("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("Class",502,G__G__Gui2_325_0_13, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGViewFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_325_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGViewFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_325_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGViewFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_325_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGViewFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_325_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__Gui2_325_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGViewFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_325_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGViewFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_325_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGViewFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_325_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGViewFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGViewFrame", 1183, G__G__Gui2_325_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGView(void) {
   /* TGView */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGView));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateRegion",1223,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 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("ItemLayout",1037,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGView",566,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGView), -1, 0, 1, 1, 4, 0, "u 'TGView' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGView), -1, 1, 1, 1, 4, 0, "u 'TGView' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGView",566,G__G__Gui2_326_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGView), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 '0' xMargin h - 'UInt_t' 0 '0' yMargin "
"h - 'UInt_t' 0 'kSunkenFrame|kDoubleBorder' options h - 'UInt_t' 0 '0' sboptions "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvas",892,G__G__Gui2_326_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGViewFrame), -1, 0, 0, 1, 1, 8, "", (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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisibleStart",1544,G__G__Gui2_326_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newTop i - 'Int_t' 0 - direction", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollCanvas",1227,G__G__Gui2_326_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newTop i - 'Int_t' 0 - direction", (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("DrawBorder",1004,(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("SetLayoutManager",1637,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLayoutManager' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawRegion",1010,G__G__Gui2_326_0_15, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollToPosition",1671,G__G__Gui2_326_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLongPosition' - 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollUp",820,G__G__Gui2_326_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pixels", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScrollDown",1031,G__G__Gui2_326_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pixels", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScrollLeft",1018,G__G__Gui2_326_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pixels", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScrollRight",1133,G__G__Gui2_326_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pixels", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVirtualSize",1442,G__G__Gui2_326_0_22, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScrollValue",1420,G__G__Gui2_326_0_23, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScrollPosition",1764,G__G__Gui2_326_0_24, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToVirtual",938,G__G__Gui2_326_0_25, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition), -1, 0, 1, 1, 1, 8, "u 'TGLongPosition' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToPhysical",1024,G__G__Gui2_326_0_26, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition), -1, 0, 1, 1, 1, 8, "u 'TGLongPosition' - 0 - coord", (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("HandleExpose",1216,(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("ChangeBackground",1606,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - -", (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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBackgroundPixmap",1947,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateBackgroundStart",2161,G__G__Gui2_326_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetViewWhiteGC",1350,G__G__Gui2_326_0_33, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_326_0_34, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGView::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_326_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGView::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_326_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGView::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_326_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGView::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_326_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__Gui2_326_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGView::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_326_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGView::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_326_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGView::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_326_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGView::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGView", 692, G__G__Gui2_326_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextView(void) {
   /* TGTextView */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextView));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "k - 'Pixel_t' 0 - bg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRegion",1010,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 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("Mark",395,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"l - 'Long_t' 0 - xPos l - 'Long_t' 0 - yPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnMark",590,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HLayout",710,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("VLayout",724,(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("GetDefaultGC",1135,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2LN_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__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextView",987,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextView), -1, 0, 1, 1, 4, 0, "u 'TGTextView' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTextView), -1, 1, 1, 1, 4, 0, "u 'TGTextView' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextView",987,G__G__Gui2_329_0_14, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextView), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 '0' sboptions k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextView",987,G__G__Gui2_329_0_15, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextView), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - parent h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h U 'TGText' - 0 - text "
"i - 'Int_t' 0 '-1' id h - 'UInt_t' 0 '0' sboptions "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextView",987,G__G__Gui2_329_0_16, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextView), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - parent h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h C - - 10 - string "
"i - 'Int_t' 0 '-1' id h - 'UInt_t' 0 '0' sboptions "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSaved",687,G__G__Gui2_329_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ToObjXCoord",1069,G__G__Gui2_329_0_18, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - xCoord l - 'Long_t' 0 - line", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ToObjYCoord",1070,G__G__Gui2_329_0_19, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - yCoord", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ToScrXCoord",1082,G__G__Gui2_329_0_20, 108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - xCoord l - 'Long_t' 0 - line", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ToScrYCoord",1083,G__G__Gui2_329_0_21, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - yCoord", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AdjustWidth",1131,G__G__Gui2_329_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadFile",768,G__G__Gui2_329_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - fname l - - 0 '0' startpos "
"l - - 0 '-1' length", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadBuffer",986,G__G__Gui2_329_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - txtbuf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,G__G__Gui2_329_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectAll",889,G__G__Gui2_329_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Search",598,G__G__Gui2_329_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - string g - 'Bool_t' 0 - direction "
"g - 'Bool_t' 0 - caseSensitive", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFont",707,G__G__Gui2_329_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'FontStruct_t' 0 - font", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnHeighestColHeight",2344,G__G__Gui2_329_0_30, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnLongestLineWidth",2276,G__G__Gui2_329_0_31, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnLineLength",1642,G__G__Gui2_329_0_32, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 0, "l - 'Long_t' 0 - line", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnLongestLine",1764,G__G__Gui2_329_0_33, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReturnLineCount",1553,G__G__Gui2_329_0_34, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSBRange",942,G__G__Gui2_329_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - direction", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHsbPosition",1438,G__G__Gui2_329_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVsbPosition",1452,G__G__Gui2_329_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - newPos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowBottom",1046,G__G__Gui2_329_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowTop",724,G__G__Gui2_329_0_39, 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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__Gui2_329_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGText' - 0 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddText",686,G__G__Gui2_329_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGText' - 0 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLine",657,G__G__Gui2_329_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLineFast",1055,G__G__Gui2_329_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - string", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Gui2_329_0_45, 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("SetBackground",1324,G__G__Gui2_329_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelectBack",1277,G__G__Gui2_329_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelectFore",1304,G__G__Gui2_329_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - p", (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 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,G__G__Gui2_329_0_51, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGText), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadOnly",1098,G__G__Gui2_329_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "*TOGGLE* *GETTER=IsReadOnly", (void*) NULL, 1);
   G__memfunc_setup("IsReadOnly",986,G__G__Gui2_329_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMarked",784,G__G__Gui2_329_0_54, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleDNDDrop",1207,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TDNDData' - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDPosition",1655,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"k - 'Atom_t' 0 - action i - 'Int_t' 0 - xroot "
"i - 'Int_t' 0 - yroot", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDEnter",1312,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Atom_t"), 0, 1, 1, 1, 0, "K - 'Atom_t' 0 - typelist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleDNDLeave",1295,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 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("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("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("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("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("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("DataChanged",1060,G__G__Gui2_329_0_66, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DataDropped",1096,G__G__Gui2_329_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fname", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Marked",596,G__G__Gui2_329_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mark", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__Gui2_329_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - word", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_329_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - word", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_329_0_71, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextView::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_329_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextView::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_329_0_73, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextView::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_329_0_74, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextView::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_329_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_329_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextView::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_329_0_80, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextView::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_329_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextView::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_329_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextView::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextView", 1113, G__G__Gui2_329_0_83, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSearchType(void) {
   /* TGSearchType */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType));
   G__memfunc_setup("TGSearchType",1171,G__G__Gui2_330_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TGSearchType", 1171, G__G__Gui2_330_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType), -1, 0, 1, 1, 1, 0, "u 'TGSearchType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGSearchType", 1297, G__G__Gui2_330_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Gui2_330_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType), -1, 1, 1, 1, 1, 0, "u 'TGSearchType' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTextEdit(void) {
   /* TGTextEdit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit));
   G__memfunc_setup("TGTextEdit",966,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit), -1, 0, 1, 1, 4, 0, "u 'TGTextEdit' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit), -1, 1, 1, 1, 4, 0, "u 'TGTextEdit' - 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("SetMenuState",1218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CursorOn",827,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CursorOff",921,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCursor",1036,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AdjustPos",925,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TObject' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCursor0GC",1112,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCursor1GC",1113,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 2, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEdit",966,G__G__Gui2_332_0_12, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit), -1, 0, 6, 1, 1, 0, 
"U 'TGWindow' - 10 '0' parent h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' h i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 '0' sboptions k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEdit",966,G__G__Gui2_332_0_13, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - parent h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h U 'TGText' - 0 - text "
"i - 'Int_t' 0 '-1' id h - 'UInt_t' 0 '0' sboptions "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGTextEdit",966,G__G__Gui2_332_0_14, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEdit), -1, 0, 7, 1, 1, 0, 
"U 'TGWindow' - 10 - parent h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h C - - 10 - string "
"i - 'Int_t' 0 '-1' id h - 'UInt_t' 0 '0' sboptions "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveFile",783,G__G__Gui2_332_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - fname g - 'Bool_t' 0 'kFALSE' saveas", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Cut",300,G__G__Gui2_332_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paste",509,G__G__Gui2_332_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsChar",680,G__G__Gui2_332_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "c - - 0 - character", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DelChar",659,G__G__Gui2_332_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BreakLine",877,G__G__Gui2_332_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrevChar",795,G__G__Gui2_332_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextChar",797,G__G__Gui2_332_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineUp",589,G__G__Gui2_332_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LineDown",800,G__G__Gui2_332_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScreenUp",805,G__G__Gui2_332_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScreenDown",1016,G__G__Gui2_332_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Home",393,G__G__Gui2_332_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("End",279,G__G__Gui2_332_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (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 '\"\"' -", (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("Search",598,G__G__Gui2_332_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"C - - 10 - string g - 'Bool_t' 0 'kTRUE' direction "
"g - 'Bool_t' 0 'kFALSE' caseSensitive", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Search",598,G__G__Gui2_332_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - close", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Replace",700,G__G__Gui2_332_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"u 'TGLongPosition' - 0 - pos C - - 10 - oldText "
"C - - 10 - newText g - 'Bool_t' 0 - direction "
"g - 'Bool_t' 0 - caseSensitive", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Goto",409,G__G__Gui2_332_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - line l - 'Long_t' 0 '0' column", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInsertMode",1318,G__G__Gui2_332_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGTextEdit::EInsertMode' - 0 'kInsert' mode", "*SUBMENU*", (void*) NULL, 1);
   G__memfunc_setup("GetInsertMode",1306,G__G__Gui2_332_0_38, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTextEditcLcLEInsertMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenu",693,G__G__Gui2_332_0_39, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPopupMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableMenu",988,G__G__Gui2_332_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", "*TOGGLE* *GETTER=IsMenuEnabled", (void*) NULL, 1);
   G__memfunc_setup("IsMenuEnabled",1276,G__G__Gui2_332_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistory",1042,G__G__Gui2_332_0_42, 85, G__get_linked_tagnum(&G__G__Gui2LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableCursorWithoutFocus",2489,G__G__Gui2_332_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCursorEnabledithoutFocus",2690,G__G__Gui2_332_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawRegion",1010,(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 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ScrollCanvas",1227,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newTop i - 'Int_t' 0 - direction", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFocus",812,G__G__Gui2_332_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCurrent",1039,G__G__Gui2_332_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLongPosition' - 0 - new_coord", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentPos",1333,G__G__Gui2_332_0_49, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGLongPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReturnLongestLineWidth",2276,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 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 - t", (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("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("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("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("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("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("FindAgain",865,G__G__Gui2_332_0_60, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Closed",602,G__G__Gui2_332_0_61, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Opened",603,G__G__Gui2_332_0_62, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Saved",499,G__G__Gui2_332_0_63, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("SavedAs",679,G__G__Gui2_332_0_64, 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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_332_0_66, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTextEdit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_332_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEdit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_332_0_68, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTextEdit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_332_0_69, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTextEdit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_332_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_332_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEdit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_332_0_75, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextEdit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_332_0_76, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTextEdit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_332_0_77, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTextEdit::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTextEdit", 1092, G__G__Gui2_332_0_78, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGSearchDialog(void) {
   /* TGSearchDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog));
   G__memfunc_setup("TGSearchDialog",1345,G__G__Gui2_336_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog), -1, 0, 7, 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 "
"U 'TGSearchType' - 0 '0' sstruct I - 'Int_t' 0 '0' ret_code "
"h - 'UInt_t' 0 'kVerticalFrame' options", (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("SetClose",802,G__G__Gui2_336_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsClose",690,G__G__Gui2_336_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TextEntered",1132,G__G__Gui2_336_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetType",706,G__G__Gui2_336_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGSearchType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SearchDialog",1190,G__G__Gui2_336_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGSearchDialog), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGSearchDialog*& (*)())(&TGSearchDialog::SearchDialog) ), 0);
   G__memfunc_setup("Class",502,G__G__Gui2_336_0_9, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGSearchDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_336_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSearchDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_336_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGSearchDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_336_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGSearchDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_336_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__Gui2_336_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSearchDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_336_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSearchDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_336_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGSearchDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_336_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGSearchDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGSearchDialog", 1471, G__G__Gui2_336_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGPrintDialog(void) {
   /* TGPrintDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog));
   G__memfunc_setup("TGPrintDialog",1272,G__G__Gui2_337_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGPrintDialog), -1, 0, 8, 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 "
"C - - 2 '0' printerName C - - 2 '0' printProg "
"I - 'Int_t' 0 '0' ret_code h - 'UInt_t' 0 'kVerticalFrame' options", (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__Gui2_337_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGPrintDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_337_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPrintDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_337_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGPrintDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_337_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGPrintDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_337_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__Gui2_337_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPrintDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_337_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPrintDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_337_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGPrintDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_337_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGPrintDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGPrintDialog", 1398, G__G__Gui2_337_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGGotoDialog(void) {
   /* TGGotoDialog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog));
   G__memfunc_setup("TGGotoDialog",1156,G__G__Gui2_338_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGGotoDialog), -1, 0, 6, 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 "
"L - 'Long_t' 0 '0' ret_code h - 'UInt_t' 0 'kVerticalFrame' options", (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__Gui2_338_0_4, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGGotoDialog::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_338_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGotoDialog::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_338_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGGotoDialog::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_338_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGGotoDialog::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_338_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__Gui2_338_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGotoDialog::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_338_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGotoDialog::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_338_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGGotoDialog::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_338_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGGotoDialog::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGGotoDialog", 1282, G__G__Gui2_338_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDoubleSlider(void) {
   /* TGDoubleSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleSlider), -1, 1, 1, 1, 4, 0, "u 'TGDoubleSlider' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetSString",1002,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TString), -1, 0, 0, 1, 2, 8, "", "returns scaling type as string", (void*) NULL, 0);
   G__memfunc_setup("FixBounds",914,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"f - 'Float_t' 1 - min f - 'Float_t' 1 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeCursor",1220,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'Event_t' - 0 - event", (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, 3);
   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, 3);
   G__memfunc_setup("SetScale",788,G__G__Gui2_341_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - scale", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Gui2_341_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,G__G__Gui2_341_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinPosition",1433,G__G__Gui2_341_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxPosition",1435,G__G__Gui2_341_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPosition",1141,G__G__Gui2_341_0_14, 121, -1, -1, 0, 2, 1, 1, 8, 
"f - 'Float_t' 1 - min f - 'Float_t' 1 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPosition",1141,G__G__Gui2_341_0_15, 121, -1, -1, 0, 2, 1, 1, 8, 
"F - 'Float_t' 0 - min F - 'Float_t' 0 - max", (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("PositionChanged",1535,G__G__Gui2_341_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Pressed",726,G__G__Gui2_341_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Released",805,G__G__Gui2_341_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_341_0_20, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDoubleSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_341_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_341_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDoubleSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_341_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDoubleSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_341_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_341_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_341_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDoubleSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_341_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_341_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDoubleSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDoubleSlider", 1495, G__G__Gui2_341_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDoubleVSlider(void) {
   /* TGDoubleVSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGDoubleVSlider",1455,G__G__Gui2_342_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleVSlider), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' h "
"h - 'UInt_t' 0 '1' type i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kVerticalFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back "
"g - 'Bool_t' 0 'kFALSE' reversed g - 'Bool_t' 0 'kFALSE' mark_ends", (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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_342_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDoubleVSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_342_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleVSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_342_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDoubleVSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_342_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDoubleVSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_342_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__Gui2_342_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleVSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_342_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDoubleVSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_342_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleVSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_342_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDoubleVSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDoubleVSlider", 1581, G__G__Gui2_342_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGDoubleHSlider(void) {
   /* TGDoubleHSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGDoubleHSlider",1441,G__G__Gui2_343_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGDoubleHSlider), -1, 0, 8, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' type i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back "
"g - 'Bool_t' 0 'kFALSE' reversed g - 'Bool_t' 0 'kFALSE' mark_ends", (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("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_343_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGDoubleHSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_343_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleHSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_343_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGDoubleHSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_343_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGDoubleHSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_343_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__Gui2_343_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleHSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_343_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDoubleHSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_343_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGDoubleHSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_343_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGDoubleHSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGDoubleHSlider", 1567, G__G__Gui2_343_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTreeLBEntry(void) {
   /* TGTreeLBEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultFontStruct",2049,G__G__Gui2_344_0_2, 107, -1, G__defined_typename("FontStruct_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (FontStruct_t (*)())(&TGTreeLBEntry::GetDefaultFontStruct) ), 0);
   G__memfunc_setup("GetDefaultGC",1135,G__G__Gui2_344_0_3, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGGC), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TGGC& (*)())(&TGTreeLBEntry::GetDefaultGC) ), 0);
   G__memfunc_setup("TGTreeLBEntry",1227,G__G__Gui2_344_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTreeLBEntry), -1, 0, 9, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGString' - 0 '0' text "
"U 'TGPicture' - 10 '0' pic i - 'Int_t' 0 '-1' id "
"U 'TGString' - 0 '0' path k - 'GContext_t' 0 'GetDefaultGC()()' norm "
"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 'kHorizontalFrame' options "
"k - 'Pixel_t' 0 'GetWhitePixel()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Gui2_344_0_5, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPicture",1020,G__G__Gui2_344_0_6, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPath",685,G__G__Gui2_344_0_7, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Activate",817,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLBEntry' - 0 - e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"k - 'Handle_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_344_0_12, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTreeLBEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_344_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTreeLBEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_344_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTreeLBEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_344_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTreeLBEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_344_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__Gui2_344_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTreeLBEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_344_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTreeLBEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_344_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTreeLBEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_344_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTreeLBEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTreeLBEntry", 1353, G__G__Gui2_344_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRegion(void) {
   /* TGRegion */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegion));
   G__memfunc_setup("TGRegion",767,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyRegion",1023,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegion",767,G__G__Gui2_347_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegion",767,G__G__Gui2_347_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"i 'TGRegion::ERegionType' - 0 'kRectangle' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegion",767,G__G__Gui2_347_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n U 'TPoint' - 0 - points "
"g - 'Bool_t' 0 'kFALSE' winding", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegion",767,G__G__Gui2_347_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - x "
"I - 'Int_t' 0 - y g - 'Bool_t' 0 'kFALSE' winding", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegion",767,G__G__Gui2_347_0_7, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 3, 1, 1, 0, 
"u 'TArrayS' - 11 - x u 'TArrayS' - 11 - y "
"g - 'Bool_t' 0 'kFALSE' winding", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegion",767,G__G__Gui2_347_0_8, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 0, "u 'TGRegion' - 11 - reg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Gui2_347_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TPoint' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Gui2_347_0_10, 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("Unite",517,G__G__Gui2_347_0_11, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Intersect",945,G__G__Gui2_347_0_12, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Subtract",840,G__G__Gui2_347_0_13, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eor",294,G__G__Gui2_347_0_14, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDimension",1222,G__G__Gui2_347_0_15, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__G__Gui2_347_0_16, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGPosition), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNull",599,G__G__Gui2_347_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEmpty",715,G__G__Gui2_347_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator|",1000,G__G__Gui2_347_0_19, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Gui2_347_0_20, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator&",914,G__G__Gui2_347_0_21, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Gui2_347_0_22, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator^",970,G__G__Gui2_347_0_23, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator|=",1061,G__G__Gui2_347_0_24, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 1, 1, 1, 1, 0, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Gui2_347_0_25, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 1, 1, 1, 1, 0, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator&=",975,G__G__Gui2_347_0_26, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 1, 1, 1, 1, 0, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Gui2_347_0_27, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 1, 1, 1, 1, 0, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator^=",1031,G__G__Gui2_347_0_28, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 1, 1, 1, 1, 0, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Gui2_347_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Gui2_347_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Gui2_347_0_31, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegion), -1, 1, 1, 1, 1, 0, "u 'TGRegion' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_347_0_32, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRegion::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_347_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRegion::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_347_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRegion::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_347_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRegion::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_347_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__Gui2_347_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRegion::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_347_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRegion::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_347_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRegion::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_347_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRegion::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGRegion", 893, G__G__Gui2_347_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGRegionWithId(void) {
   /* TGRegionWithId */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId), -1, 1, 1, 1, 4, 0, "u 'TGRegionWithId' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGRegionWithId",1352,G__G__Gui2_349_0_2, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegionWithId",1352,G__G__Gui2_349_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId), -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y h - 'UInt_t' 0 - w "
"h - 'UInt_t' 0 - h i 'TGRegion::ERegionType' - 0 'kRectangle' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegionWithId",1352,G__G__Gui2_349_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - n "
"U 'TPoint' - 0 - points g - 'Bool_t' 0 'kFALSE' winding", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegionWithId",1352,G__G__Gui2_349_0_5, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId), -1, 0, 1, 1, 1, 0, "u 'TGRegionWithId' - 11 - reg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGRegionWithId",1352,G__G__Gui2_349_0_6, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId), -1, 0, 2, 1, 1, 0, 
"u 'TGRegion' - 11 - reg i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetId",461,G__G__Gui2_349_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetToolTipText",1424,G__G__Gui2_349_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGToolTip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToolTipText",1436,G__G__Gui2_349_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - text l - 'Long_t' 0 - delayms "
"U 'TGFrame' - 10 - frame", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPopup",820,G__G__Gui2_349_0_10, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPopupMenu), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPopup",832,G__G__Gui2_349_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPopupMenu' - 0 - popup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplayPopup",1258,G__G__Gui2_349_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_349_0_13, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGRegionWithId::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_349_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRegionWithId::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_349_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGRegionWithId::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_349_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGRegionWithId::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_349_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__Gui2_349_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRegionWithId::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_349_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRegionWithId::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_349_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGRegionWithId::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_349_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGRegionWithId::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGRegionWithId", 1478, G__G__Gui2_349_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGImageMap(void) {
   /* TGImageMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap));
   G__memfunc_setup("TGImageMap",924,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap), -1, 0, 1, 1, 4, 0, "u 'TGImageMap' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap), -1, 1, 1, 1, 4, 0, "u 'TGImageMap' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGImageMap",924,G__G__Gui2_350_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p U 'TGPicture' - 10 '0' pic", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGImageMap",924,G__G__Gui2_350_0_4, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGImageMap), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 - p u 'TString' - 11 - pic", (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("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("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("GetNavMode",970,G__G__Gui2_350_0_8, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGImageMapcLcLENavMode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRegion",877,G__G__Gui2_350_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGRegion' - 11 - region i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreatePopup",1128,G__G__Gui2_350_0_10, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPopupMenu), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPopup",820,G__G__Gui2_350_0_11, 85, G__get_linked_tagnum(&G__G__Gui2LN_TGPopupMenu), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToolTipText",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - text l - 'Long_t' 0 '300' delayms", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetToolTipText",1436,G__G__Gui2_350_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id C - - 10 - text "
"l - 'Long_t' 0 '300' delayms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCursor",938,G__G__Gui2_350_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ECursor' - 0 'kHand' cursor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPicture",1032,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - -", "disabled", (void*) NULL, 1);
   G__memfunc_setup("RegionClicked",1299,G__G__Gui2_350_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_350_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__Gui2_350_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("OnMouseOver",1122,G__G__Gui2_350_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("OnMouseOut",1022,G__G__Gui2_350_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_350_0_21, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGImageMap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_350_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGImageMap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_350_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGImageMap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_350_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGImageMap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_350_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Gui2_350_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGImageMap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_350_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGImageMap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_350_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGImageMap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_350_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGImageMap::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGImageMap", 1050, G__G__Gui2_350_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGApplication(void) {
   /* TGApplication */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGApplication));
   G__memfunc_setup("TGApplication",1295,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGApplication), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadGraphicsLibs",1595,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGApplication",1295,G__G__Gui2_356_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGApplication), -1, 0, 5, 1, 1, 0, 
"C - - 10 - appClassName I - 'Int_t' 0 - argc "
"C - - 2 - argv Y - - 0 '0' options "
"i - 'Int_t' 0 '0' numOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - argc C - - 2 - argv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Gui2_356_0_5, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGApplication::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_356_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGApplication::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_356_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGApplication::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_356_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGApplication::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_356_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__Gui2_356_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGApplication::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_356_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGApplication::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_356_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGApplication::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_356_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGApplication::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGApplication", 1421, G__G__Gui2_356_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGXYLayoutHints(void) {
   /* TGXYLayoutHints */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints));
   G__memfunc_setup("TGXYLayoutHints",1488,G__G__Gui2_357_0_1, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w d - 'Double_t' 0 - h "
"h - 'UInt_t' 0 'kLRubberX|kLRubberY' rubberFlag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Gui2_357_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Gui2_357_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW",375,G__G__Gui2_357_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetH",360,G__G__Gui2_357_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFlag",666,G__G__Gui2_357_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__G__Gui2_357_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__G__Gui2_357_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetW",387,G__G__Gui2_357_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetH",372,G__G__Gui2_357_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlag",678,G__G__Gui2_357_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - flag", (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__Gui2_357_0_13, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGXYLayoutHints::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_357_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGXYLayoutHints::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_357_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGXYLayoutHints::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_357_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGXYLayoutHints::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_357_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__Gui2_357_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGXYLayoutHints::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_357_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGXYLayoutHints::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_357_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGXYLayoutHints::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_357_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGXYLayoutHints::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGXYLayoutHints", 1488, G__G__Gui2_357_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayoutHints), -1, 0, 1, 1, 1, 0, "u 'TGXYLayoutHints' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGXYLayoutHints", 1614, G__G__Gui2_357_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGXYLayout(void) {
   /* TGXYLayout */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout));
   G__memfunc_setup("TGXYLayout",970,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout), -1, 0, 1, 1, 2, 0, "u 'TGXYLayout' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout), -1, 1, 1, 1, 2, 0, "u 'TGXYLayout' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGXYLayout",970,G__G__Gui2_359_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGXYLayout), -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__Gui2LN_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("NewSize",709,G__G__Gui2_359_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Gui2_359_0_8, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGXYLayout::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_359_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGXYLayout::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_359_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGXYLayout::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_359_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGXYLayout::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_359_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__Gui2_359_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGXYLayout::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_359_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGXYLayout::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_359_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGXYLayout::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_359_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGXYLayout::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGXYLayout", 1096, G__G__Gui2_359_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTripleVSlider(void) {
   /* TGTripleVSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointerPos",1343,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - z i - 'Int_t' 0 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGTripleVSlider",1476,G__G__Gui2_360_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTripleVSlider), -1, 0, 10, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' h "
"h - 'UInt_t' 0 '1' type i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kVerticalFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back "
"g - 'Bool_t' 0 'kFALSE' reversed g - 'Bool_t' 0 'kFALSE' mark_ends "
"g - 'Bool_t' 0 'kTRUE' constrained g - 'Bool_t' 0 'kFALSE' relative", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PointerPositionChanged",2272,G__G__Gui2_360_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DrawPointer",1135,G__G__Gui2_360_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointerPosition",1878,G__G__Gui2_360_0_6, 102, -1, G__defined_typename("Float_t"), 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("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("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("SetConstrained",1446,G__G__Gui2_360_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointerPosition",1890,G__G__Gui2_360_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRelative",1128,G__G__Gui2_360_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' rel", (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__Gui2_360_0_14, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTripleVSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_360_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTripleVSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_360_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTripleVSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_360_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTripleVSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_360_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__Gui2_360_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTripleVSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_360_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTripleVSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_360_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTripleVSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_360_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTripleVSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTripleVSlider", 1602, G__G__Gui2_360_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGTripleHSlider(void) {
   /* TGTripleHSlider */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider));
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointerPos",1343,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - z i - 'Int_t' 0 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGTripleHSlider",1462,G__G__Gui2_361_0_3, 105, G__get_linked_tagnum(&G__G__Gui2LN_TGTripleHSlider), -1, 0, 10, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '1' w "
"h - 'UInt_t' 0 '1' type i - 'Int_t' 0 '-1' id "
"h - 'UInt_t' 0 'kHorizontalFrame' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back "
"g - 'Bool_t' 0 'kFALSE' reversed g - 'Bool_t' 0 'kFALSE' mark_ends "
"g - 'Bool_t' 0 'kTRUE' constrained g - 'Bool_t' 0 'kFALSE' relative", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PointerPositionChanged",2272,G__G__Gui2_361_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DrawPointer",1135,G__G__Gui2_361_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointerPosition",1878,G__G__Gui2_361_0_6, 102, -1, G__defined_typename("Float_t"), 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("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("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("SetConstrained",1446,G__G__Gui2_361_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointerPosition",1890,G__G__Gui2_361_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRelative",1128,G__G__Gui2_361_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' rel", (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__Gui2_361_0_14, 85, G__get_linked_tagnum(&G__G__Gui2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTripleHSlider::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Gui2_361_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTripleHSlider::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Gui2_361_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTripleHSlider::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Gui2_361_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTripleHSlider::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Gui2LN_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__Gui2_361_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__Gui2_361_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTripleHSlider::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Gui2_361_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTripleHSlider::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Gui2_361_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTripleHSlider::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Gui2_361_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTripleHSlider::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGTripleHSlider", 1588, G__G__Gui2_361_0_26, (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__Gui2() {
}

/*********************************************************
* 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*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ETextLayoutFlags),-1,-1,1,"kTextWholeWords=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ETextLayoutFlags),-1,-1,1,"kTextAtLeastOne=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ETextLayoutFlags),-1,-1,1,"kTextPartialOK=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ETextLayoutFlags),-1,-1,1,"kTextIgnoreTabs=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ETextLayoutFlags),-1,-1,1,"kTextIgnoreNewlines=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightNormal=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightMedium=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightBold=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightLight=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightDemibold=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightBlack=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontWeight),-1,-1,1,"kFontWeightUnknown=-1",0,(char*)NULL);
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontSlant),-1,-1,1,"kFontSlantRoman=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontSlant),-1,-1,1,"kFontSlantItalic=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontSlant),-1,-1,1,"kFontSlantOblique=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFontSlant),-1,-1,1,"kFontSlantUnknown=-1",0,(char*)NULL);
}

static void G__cpp_setup_global5() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EScrollBarMode),-1,-1,1,"kSBHorizontal=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EScrollBarMode),-1,-1,1,"kSBVertical=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ESliderType),-1,-1,1,"kSlider1=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ESliderType),-1,-1,1,"kSlider2=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ESliderType),-1,-1,1,"kScaleNo=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ESliderType),-1,-1,1,"kScaleDownRight=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_ESliderType),-1,-1,1,"kScaleBoth=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,1,"kLVLargeIcons=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,1,"kLVSmallIcons=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,1,"kLVList=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EListViewMode),-1,-1,1,"kLVDetails=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,1,"kSortByName=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,1,"kSortByType=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,1,"kSortBySize=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,1,"kSortByDate=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,1,"kSortByOwner=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFSSortMode),-1,-1,1,"kSortByGroup=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFileDialogMode),-1,-1,1,"kFDOpen=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EFileDialogMode),-1,-1,1,"kFDSave=1",0,(char*)NULL);
}

static void G__cpp_setup_global6() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EDoubleSliderScale),-1,-1,1,"kDoubleScaleNo=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EDoubleSliderScale),-1,-1,1,"kDoubleScaleDownRight=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Gui2LN_EDoubleSliderScale),-1,-1,1,"kDoubleScaleBoth=4",0,(char*)NULL);
   G__memvar_setup((void*)(&gCurrentRegion),85,0,0,G__get_linked_tagnum(&G__G__Gui2LN_TGRegionWithId),-1,-1,1,"gCurrentRegion=",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Gui2() {
  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() {
}

static void G__cpp_setup_func4() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Gui2() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Gui2LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_TGClient = { "TGClient" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TRefCnt = { "TRefCnt" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TRegexp = { "TRegexp" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGResourcePool = { "TGResourcePool" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGPicturePool = { "TGPicturePool" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGPicture = { "TGPicture" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGGCPool = { "TGGCPool" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGGC = { "TGGC" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFontPool = { "TGFontPool" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFont = { "TGFont" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGMimeTypes = { "TGMimeTypes" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_ECursor = { "ECursor" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TPoint = { "TPoint" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGDimension = { "TGDimension" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGPosition = { "TGPosition" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLongPosition = { "TGLongPosition" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGRectangle = { "TGRectangle" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_THashTable = { "THashTable" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TObjString = { "TObjString" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_ETextLayoutFlags = { "ETextLayoutFlags" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_EFontWeight = { "EFontWeight" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_EFontSlant = { "EFontSlant" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_FontMetrics_t = { "FontMetrics_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_FontAttributes_t = { "FontAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_LayoutChunk_t = { "LayoutChunk_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextLayout = { "TGTextLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_FontStateMap_t = { "FontStateMap_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_XLFDAttributes_t = { "XLFDAttributes_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFrameElement = { "TGFrameElement" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLayoutManager = { "TGLayoutManager" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGString = { "TGString" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGVFileSplitter = { "TGVFileSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TDNDData = { "TDNDData" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGGroupFrame = { "TGGroupFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGHeaderFrame = { "TGHeaderFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGWidget = { "TGWidget" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGToolTip = { "TGToolTip" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_EScrollBarMode = { "EScrollBarMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGScrollBarElement = { "TGScrollBarElement" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGScrollBar = { "TGScrollBar" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGHScrollBar = { "TGHScrollBar" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGVScrollBar = { "TGVScrollBar" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGViewPort = { "TGViewPort" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGCanvas = { "TGCanvas" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListView = { "TGListView" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGContainer = { "TGContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGCanvascLcLdA = { "TGCanvas::$" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListBox = { "TGListBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLBEntry = { "TGLBEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextLBEntry = { "TGTextLBEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLineLBEntry = { "TGLineLBEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGIconLBEntry = { "TGIconLBEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLBContainer = { "TGLBContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGComboBoxPopup = { "TGComboBoxPopup" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLineStyleComboBox = { "TGLineStyleComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLineWidthComboBox = { "TGLineWidthComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFontTypeComboBox = { "TGFontTypeComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTabElement = { "TGTabElement" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTab = { "TGTab" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTabLayout = { "TGTabLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_ESliderType = { "ESliderType" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGSlider = { "TGSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGVSlider = { "TGVSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGHSlider = { "TGHSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGSelectedPicture = { "TGSelectedPicture" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGSplitter = { "TGSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGVSplitter = { "TGVSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGHSplitter = { "TGHSplitter" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_EListViewMode = { "EListViewMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLVContainer = { "TGLVContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLVEntry = { "TGLVEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TOrdCollection = { "TOrdCollection" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGMime = { "TGMime" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TBufferFile = { "TBufferFile" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_EFSSortMode = { "EFSSortMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFileContainer = { "TGFileContainer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TViewUpdateTimer = { "TViewUpdateTimer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFileItem = { "TGFileItem" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_FileStat_t = { "FileStat_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_EFileDialogMode = { "EFileDialogMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextBuffer = { "TGTextBuffer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFSComboBox = { "TGFSComboBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFileInfo = { "TGFileInfo" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGFileDialog = { "TGFileDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGStatusBarPart = { "TGStatusBarPart" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGStatusBar = { "TGStatusBar" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TBox = { "TBox" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_ToolBarData_t = { "ToolBarData_t" , 115 , -1 };
G__linked_taginfo G__G__Gui2LN_TGToolBar = { "TGToolBar" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListTree = { "TGListTree" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListTreeItemStd = { "TGListTreeItemStd" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListTreecLcLEColorMarkupMode = { "TGListTree::EColorMarkupMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGListTreecLcLECheckMode = { "TGListTree::ECheckMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextLine = { "TGTextLine" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGText = { "TGText" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGViewFrame = { "TGViewFrame" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGView = { "TGView" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGViewcLcLdA = { "TGView::$" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TViewTimer = { "TViewTimer" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextView = { "TGTextView" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGSearchType = { "TGSearchType" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextEditHist = { "TGTextEditHist" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextEdit = { "TGTextEdit" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextEditcLcLEInsertMode = { "TGTextEdit::EInsertMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTextEditcLcLdA = { "TGTextEdit::$" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGIcon = { "TGIcon" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGSearchDialog = { "TGSearchDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGPrintDialog = { "TGPrintDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGGotoDialog = { "TGGotoDialog" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_EDoubleSliderScale = { "EDoubleSliderScale" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGDoubleSlider = { "TGDoubleSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGDoubleVSlider = { "TGDoubleVSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGDoubleHSlider = { "TGDoubleHSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTreeLBEntry = { "TGTreeLBEntry" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGRegionData = { "TGRegionData" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TArrayS = { "TArrayS" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGRegion = { "TGRegion" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGRegioncLcLERegionType = { "TGRegion::ERegionType" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGRegionWithId = { "TGRegionWithId" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGImageMap = { "TGImageMap" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGImageMapcLcLENavMode = { "TGImageMap::ENavMode" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TApplication = { "TApplication" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGApplication = { "TGApplication" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGXYLayoutHints = { "TGXYLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag = { "TGXYLayoutHints::ERubberFlag" , 101 , -1 };
G__linked_taginfo G__G__Gui2LN_TGXYLayout = { "TGXYLayout" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTripleVSlider = { "TGTripleVSlider" , 99 , -1 };
G__linked_taginfo G__G__Gui2LN_TGTripleHSlider = { "TGTripleHSlider" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Gui2() {
  G__G__Gui2LN_TClass.tagnum = -1 ;
  G__G__Gui2LN_TBuffer.tagnum = -1 ;
  G__G__Gui2LN_TMemberInspector.tagnum = -1 ;
  G__G__Gui2LN_TObject.tagnum = -1 ;
  G__G__Gui2LN_TNamed.tagnum = -1 ;
  G__G__Gui2LN_TString.tagnum = -1 ;
  G__G__Gui2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Gui2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Gui2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui2LN_TList.tagnum = -1 ;
  G__G__Gui2LN_TTimer.tagnum = -1 ;
  G__G__Gui2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Gui2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui2LN_Event_t.tagnum = -1 ;
  G__G__Gui2LN_TGClient.tagnum = -1 ;
  G__G__Gui2LN_TGObject.tagnum = -1 ;
  G__G__Gui2LN_TRefCnt.tagnum = -1 ;
  G__G__Gui2LN_TRegexp.tagnum = -1 ;
  G__G__Gui2LN_TQObject.tagnum = -1 ;
  G__G__Gui2LN_TGWindow.tagnum = -1 ;
  G__G__Gui2LN_TGResourcePool.tagnum = -1 ;
  G__G__Gui2LN_TGPicturePool.tagnum = -1 ;
  G__G__Gui2LN_TGPicture.tagnum = -1 ;
  G__G__Gui2LN_TGGCPool.tagnum = -1 ;
  G__G__Gui2LN_TGGC.tagnum = -1 ;
  G__G__Gui2LN_TGFontPool.tagnum = -1 ;
  G__G__Gui2LN_TGFont.tagnum = -1 ;
  G__G__Gui2LN_TGMimeTypes.tagnum = -1 ;
  G__G__Gui2LN_ECursor.tagnum = -1 ;
  G__G__Gui2LN_TPoint.tagnum = -1 ;
  G__G__Gui2LN_TGDimension.tagnum = -1 ;
  G__G__Gui2LN_TGPosition.tagnum = -1 ;
  G__G__Gui2LN_TGLongPosition.tagnum = -1 ;
  G__G__Gui2LN_TGRectangle.tagnum = -1 ;
  G__G__Gui2LN_THashTable.tagnum = -1 ;
  G__G__Gui2LN_TObjString.tagnum = -1 ;
  G__G__Gui2LN_ETextLayoutFlags.tagnum = -1 ;
  G__G__Gui2LN_EFontWeight.tagnum = -1 ;
  G__G__Gui2LN_EFontSlant.tagnum = -1 ;
  G__G__Gui2LN_FontMetrics_t.tagnum = -1 ;
  G__G__Gui2LN_FontAttributes_t.tagnum = -1 ;
  G__G__Gui2LN_LayoutChunk_t.tagnum = -1 ;
  G__G__Gui2LN_TGTextLayout.tagnum = -1 ;
  G__G__Gui2LN_FontStateMap_t.tagnum = -1 ;
  G__G__Gui2LN_XLFDAttributes_t.tagnum = -1 ;
  G__G__Gui2LN_TGFrame.tagnum = -1 ;
  G__G__Gui2LN_TGCompositeFrame.tagnum = -1 ;
  G__G__Gui2LN_TGLayoutHints.tagnum = -1 ;
  G__G__Gui2LN_TGFrameElement.tagnum = -1 ;
  G__G__Gui2LN_TGLayoutManager.tagnum = -1 ;
  G__G__Gui2LN_TGString.tagnum = -1 ;
  G__G__Gui2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Gui2LN_TGTextButton.tagnum = -1 ;
  G__G__Gui2LN_TGVFileSplitter.tagnum = -1 ;
  G__G__Gui2LN_TDNDData.tagnum = -1 ;
  G__G__Gui2LN_TGHorizontalFrame.tagnum = -1 ;
  G__G__Gui2LN_TGMainFrame.tagnum = -1 ;
  G__G__Gui2LN_TGTransientFrame.tagnum = -1 ;
  G__G__Gui2LN_TGGroupFrame.tagnum = -1 ;
  G__G__Gui2LN_TGHeaderFrame.tagnum = -1 ;
  G__G__Gui2LN_TGWidget.tagnum = -1 ;
  G__G__Gui2LN_TGToolTip.tagnum = -1 ;
  G__G__Gui2LN_TGPopupMenu.tagnum = -1 ;
  G__G__Gui2LN_TGButton.tagnum = -1 ;
  G__G__Gui2LN_TGPictureButton.tagnum = -1 ;
  G__G__Gui2LN_TGCheckButton.tagnum = -1 ;
  G__G__Gui2LN_TGRadioButton.tagnum = -1 ;
  G__G__Gui2LN_EScrollBarMode.tagnum = -1 ;
  G__G__Gui2LN_TGScrollBarElement.tagnum = -1 ;
  G__G__Gui2LN_TGScrollBar.tagnum = -1 ;
  G__G__Gui2LN_TGHScrollBar.tagnum = -1 ;
  G__G__Gui2LN_TGVScrollBar.tagnum = -1 ;
  G__G__Gui2LN_TGViewPort.tagnum = -1 ;
  G__G__Gui2LN_TGCanvas.tagnum = -1 ;
  G__G__Gui2LN_TGListView.tagnum = -1 ;
  G__G__Gui2LN_TGContainer.tagnum = -1 ;
  G__G__Gui2LN_TGCanvascLcLdA.tagnum = -1 ;
  G__G__Gui2LN_TGListBox.tagnum = -1 ;
  G__G__Gui2LN_TGLBEntry.tagnum = -1 ;
  G__G__Gui2LN_TGTextLBEntry.tagnum = -1 ;
  G__G__Gui2LN_TGLineLBEntry.tagnum = -1 ;
  G__G__Gui2LN_TGIconLBEntry.tagnum = -1 ;
  G__G__Gui2LN_TGLBContainer.tagnum = -1 ;
  G__G__Gui2LN_TGTextEntry.tagnum = -1 ;
  G__G__Gui2LN_TGComboBoxPopup.tagnum = -1 ;
  G__G__Gui2LN_TGComboBox.tagnum = -1 ;
  G__G__Gui2LN_TGLineStyleComboBox.tagnum = -1 ;
  G__G__Gui2LN_TGLineWidthComboBox.tagnum = -1 ;
  G__G__Gui2LN_TGFontTypeComboBox.tagnum = -1 ;
  G__G__Gui2LN_TGTabElement.tagnum = -1 ;
  G__G__Gui2LN_TGTab.tagnum = -1 ;
  G__G__Gui2LN_TGTabLayout.tagnum = -1 ;
  G__G__Gui2LN_ESliderType.tagnum = -1 ;
  G__G__Gui2LN_TGSlider.tagnum = -1 ;
  G__G__Gui2LN_TGVSlider.tagnum = -1 ;
  G__G__Gui2LN_TGHSlider.tagnum = -1 ;
  G__G__Gui2LN_TGSelectedPicture.tagnum = -1 ;
  G__G__Gui2LN_TGSplitter.tagnum = -1 ;
  G__G__Gui2LN_TGVSplitter.tagnum = -1 ;
  G__G__Gui2LN_TGHSplitter.tagnum = -1 ;
  G__G__Gui2LN_EListViewMode.tagnum = -1 ;
  G__G__Gui2LN_TGLVContainer.tagnum = -1 ;
  G__G__Gui2LN_TGLVEntry.tagnum = -1 ;
  G__G__Gui2LN_TOrdCollection.tagnum = -1 ;
  G__G__Gui2LN_TGMime.tagnum = -1 ;
  G__G__Gui2LN_TBufferFile.tagnum = -1 ;
  G__G__Gui2LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__G__Gui2LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Gui2LN_EFSSortMode.tagnum = -1 ;
  G__G__Gui2LN_TGFileContainer.tagnum = -1 ;
  G__G__Gui2LN_TViewUpdateTimer.tagnum = -1 ;
  G__G__Gui2LN_TGFileItem.tagnum = -1 ;
  G__G__Gui2LN_FileStat_t.tagnum = -1 ;
  G__G__Gui2LN_EFileDialogMode.tagnum = -1 ;
  G__G__Gui2LN_TGTextBuffer.tagnum = -1 ;
  G__G__Gui2LN_TGFSComboBox.tagnum = -1 ;
  G__G__Gui2LN_TGFileInfo.tagnum = -1 ;
  G__G__Gui2LN_TGFileDialog.tagnum = -1 ;
  G__G__Gui2LN_TGStatusBarPart.tagnum = -1 ;
  G__G__Gui2LN_TGStatusBar.tagnum = -1 ;
  G__G__Gui2LN_TGLabel.tagnum = -1 ;
  G__G__Gui2LN_TVirtualPad.tagnum = -1 ;
  G__G__Gui2LN_TBox.tagnum = -1 ;
  G__G__Gui2LN_TMap.tagnum = -1 ;
  G__G__Gui2LN_ToolBarData_t.tagnum = -1 ;
  G__G__Gui2LN_TGToolBar.tagnum = -1 ;
  G__G__Gui2LN_TGListTreeItem.tagnum = -1 ;
  G__G__Gui2LN_TGListTree.tagnum = -1 ;
  G__G__Gui2LN_TGListTreeItemStd.tagnum = -1 ;
  G__G__Gui2LN_TGListTreecLcLEColorMarkupMode.tagnum = -1 ;
  G__G__Gui2LN_TGListTreecLcLECheckMode.tagnum = -1 ;
  G__G__Gui2LN_TGTextLine.tagnum = -1 ;
  G__G__Gui2LN_TGText.tagnum = -1 ;
  G__G__Gui2LN_TGViewFrame.tagnum = -1 ;
  G__G__Gui2LN_TGView.tagnum = -1 ;
  G__G__Gui2LN_TGViewcLcLdA.tagnum = -1 ;
  G__G__Gui2LN_TViewTimer.tagnum = -1 ;
  G__G__Gui2LN_TGTextView.tagnum = -1 ;
  G__G__Gui2LN_TGSearchType.tagnum = -1 ;
  G__G__Gui2LN_TGTextEditHist.tagnum = -1 ;
  G__G__Gui2LN_TGTextEdit.tagnum = -1 ;
  G__G__Gui2LN_TGTextEditcLcLEInsertMode.tagnum = -1 ;
  G__G__Gui2LN_TGTextEditcLcLdA.tagnum = -1 ;
  G__G__Gui2LN_TGIcon.tagnum = -1 ;
  G__G__Gui2LN_TGSearchDialog.tagnum = -1 ;
  G__G__Gui2LN_TGPrintDialog.tagnum = -1 ;
  G__G__Gui2LN_TGGotoDialog.tagnum = -1 ;
  G__G__Gui2LN_EDoubleSliderScale.tagnum = -1 ;
  G__G__Gui2LN_TGDoubleSlider.tagnum = -1 ;
  G__G__Gui2LN_TGDoubleVSlider.tagnum = -1 ;
  G__G__Gui2LN_TGDoubleHSlider.tagnum = -1 ;
  G__G__Gui2LN_TGTreeLBEntry.tagnum = -1 ;
  G__G__Gui2LN_TGRegionData.tagnum = -1 ;
  G__G__Gui2LN_TArrayS.tagnum = -1 ;
  G__G__Gui2LN_TGRegion.tagnum = -1 ;
  G__G__Gui2LN_TGRegioncLcLERegionType.tagnum = -1 ;
  G__G__Gui2LN_TGRegionWithId.tagnum = -1 ;
  G__G__Gui2LN_TGImageMap.tagnum = -1 ;
  G__G__Gui2LN_TGImageMapcLcLENavMode.tagnum = -1 ;
  G__G__Gui2LN_TApplication.tagnum = -1 ;
  G__G__Gui2LN_TGApplication.tagnum = -1 ;
  G__G__Gui2LN_TGXYLayoutHints.tagnum = -1 ;
  G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag.tagnum = -1 ;
  G__G__Gui2LN_TGXYLayout.tagnum = -1 ;
  G__G__Gui2LN_TGTripleVSlider.tagnum = -1 ;
  G__G__Gui2LN_TGTripleHSlider.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Gui2() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TString);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TTimer);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGClient);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TRefCnt);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TRegexp);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGWindow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGResourcePool),sizeof(TGResourcePool),-1,62464,"Graphics resource pool",G__setup_memvarTGResourcePool,G__setup_memfuncTGResourcePool);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGPicturePool);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGPicture);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGGCPool);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGGC);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFontPool),sizeof(TGFontPool),-1,65024,"Font pool",G__setup_memvarTGFontPool,G__setup_memfuncTGFontPool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFont),sizeof(TGFont),-1,65024,"GUI font description",G__setup_memvarTGFont,G__setup_memfuncTGFont);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGMimeTypes),sizeof(TGMimeTypes),-1,65024,"Pool of mime type objects",G__setup_memvarTGMimeTypes,G__setup_memfuncTGMimeTypes);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_ECursor);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TPoint);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGDimension);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGPosition);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLongPosition);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGRectangle);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_THashTable);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TObjString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_ETextLayoutFlags),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EFontWeight),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EFontSlant),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_FontMetrics_t),sizeof(FontMetrics_t),-1,0,(char*)NULL,G__setup_memvarFontMetrics_t,G__setup_memfuncFontMetrics_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_FontAttributes_t),sizeof(FontAttributes_t),-1,2816,(char*)NULL,G__setup_memvarFontAttributes_t,G__setup_memfuncFontAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_LayoutChunk_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextLayout),sizeof(TGTextLayout),-1,32512,"Keep track of string  measurement information.",G__setup_memvarTGTextLayout,G__setup_memfuncTGTextLayout);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_FontStateMap_t);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_XLFDAttributes_t);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFrameElement);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLayoutManager);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGString);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGVFileSplitter),sizeof(TGVFileSplitter),-1,62720,"A vertical file frame splitter",G__setup_memvarTGVFileSplitter,G__setup_memfuncTGVFileSplitter);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TDNDData);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGHorizontalFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTransientFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGGroupFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGHeaderFrame);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGWidget);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGToolTip),sizeof(TGToolTip),-1,65280,"One or multiple lines help text",G__setup_memvarTGToolTip,G__setup_memfuncTGToolTip);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGPopupMenu);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGButton);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGPictureButton);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGCheckButton);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGRadioButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EScrollBarMode),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGScrollBarElement),sizeof(TGScrollBarElement),-1,65280,"Scrollbar element (head, tail, slider)",G__setup_memvarTGScrollBarElement,G__setup_memfuncTGScrollBarElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGScrollBar),sizeof(TGScrollBar),-1,65285,"Scrollbar widget",G__setup_memvarTGScrollBar,G__setup_memfuncTGScrollBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGHScrollBar),sizeof(TGHScrollBar),-1,62720,"Horizontal scrollbar widget",G__setup_memvarTGHScrollBar,G__setup_memfuncTGHScrollBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGVScrollBar),sizeof(TGVScrollBar),-1,62720,"Vertical scrollbar widget",G__setup_memvarTGVScrollBar,G__setup_memfuncTGVScrollBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGViewPort),sizeof(TGViewPort),-1,64256,"Viewport through which to look at a container frame",G__setup_memvarTGViewPort,G__setup_memfuncTGViewPort);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGCanvas),sizeof(TGCanvas),-1,65280,"A canvas with two scrollbars and a viewport",G__setup_memvarTGCanvas,G__setup_memfuncTGCanvas);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListView),sizeof(TGListView),-1,65024,"List view widget (iconbox, small icons or tabular view)",G__setup_memvarTGListView,G__setup_memfuncTGListView);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGContainer),sizeof(TGContainer),-1,65280,"Canvas container",G__setup_memvarTGContainer,G__setup_memfuncTGContainer);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGCanvascLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListBox),sizeof(TGListBox),-1,65280,"Listbox widget",G__setup_memvarTGListBox,G__setup_memfuncTGListBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLBEntry),sizeof(TGLBEntry),-1,61696,"Basic listbox entry",G__setup_memvarTGLBEntry,G__setup_memfuncTGLBEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextLBEntry),sizeof(TGTextLBEntry),-1,65280,"Text listbox entry",G__setup_memvarTGTextLBEntry,G__setup_memfuncTGTextLBEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLineLBEntry),sizeof(TGLineLBEntry),-1,65280,"Line width listbox entry",G__setup_memvarTGLineLBEntry,G__setup_memfuncTGLineLBEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGIconLBEntry),sizeof(TGIconLBEntry),-1,65280,"Icon + text listbox entry",G__setup_memvarTGIconLBEntry,G__setup_memfuncTGIconLBEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLBContainer),sizeof(TGLBContainer),-1,65280,"Listbox container",G__setup_memvarTGLBContainer,G__setup_memfuncTGLBContainer);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGComboBoxPopup),sizeof(TGComboBoxPopup),-1,61696,"Combobox popup window",G__setup_memvarTGComboBoxPopup,G__setup_memfuncTGComboBoxPopup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGComboBox),sizeof(TGComboBox),-1,65280,"Combo box widget",G__setup_memvarTGComboBox,G__setup_memfuncTGComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLineStyleComboBox),sizeof(TGLineStyleComboBox),-1,61696,"Line style combobox widget",G__setup_memvarTGLineStyleComboBox,G__setup_memfuncTGLineStyleComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLineWidthComboBox),sizeof(TGLineWidthComboBox),-1,61696,"Line width combobox widget",G__setup_memvarTGLineWidthComboBox,G__setup_memfuncTGLineWidthComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFontTypeComboBox),sizeof(TGFontTypeComboBox),-1,62720,"Font type combobox widget",G__setup_memvarTGFontTypeComboBox,G__setup_memfuncTGFontTypeComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTabElement),sizeof(TGTabElement),-1,65280,"Little tab on tab widget",G__setup_memvarTGTabElement,G__setup_memfuncTGTabElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTab),sizeof(TGTab),-1,65280,"Tab widget",G__setup_memvarTGTab,G__setup_memfuncTGTab);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTabLayout),sizeof(TGTabLayout),-1,64000,"Layout manager for TGTab widget",G__setup_memvarTGTabLayout,G__setup_memfuncTGTabLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_ESliderType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGSlider),sizeof(TGSlider),-1,65283,"Slider widget abstract base class",G__setup_memvarTGSlider,G__setup_memfuncTGSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGVSlider),sizeof(TGVSlider),-1,62720,"Vertical slider widget",G__setup_memvarTGVSlider,G__setup_memfuncTGVSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGHSlider),sizeof(TGHSlider),-1,62720,"Horizontal slider widget",G__setup_memvarTGHSlider,G__setup_memfuncTGHSlider);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGSelectedPicture);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGSplitter),sizeof(TGSplitter),-1,65284,"A frame splitter abstract base class",G__setup_memvarTGSplitter,G__setup_memfuncTGSplitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGVSplitter),sizeof(TGVSplitter),-1,65280,"A vertical frame splitter",G__setup_memvarTGVSplitter,G__setup_memfuncTGVSplitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGHSplitter),sizeof(TGHSplitter),-1,65280,"A horizontal frame splitter",G__setup_memvarTGHSplitter,G__setup_memfuncTGHSplitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EListViewMode),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLVContainer),sizeof(TGLVContainer),-1,65024,"Listview container",G__setup_memvarTGLVContainer,G__setup_memfuncTGLVContainer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLVEntry),sizeof(TGLVEntry),-1,65280,"Item that goes into a TGListView container",G__setup_memvarTGLVEntry,G__setup_memfuncTGLVEntry);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TOrdCollection);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGMime);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TBufferFile);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EFSSortMode),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFileContainer),sizeof(TGFileContainer),-1,62720,"Container containing file system objects",G__setup_memvarTGFileContainer,G__setup_memfuncTGFileContainer);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TViewUpdateTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFileItem),sizeof(TGFileItem),-1,62720,"Class representing file system object",G__setup_memvarTGFileItem,G__setup_memfuncTGFileItem);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_FileStat_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EFileDialogMode),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextBuffer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFSComboBox),sizeof(TGFSComboBox),-1,61696,"Combo box widget for file system path",G__setup_memvarTGFSComboBox,G__setup_memfuncTGFSComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFileInfo),sizeof(TGFileInfo),-1,3840,(char*)NULL,G__setup_memvarTGFileInfo,G__setup_memfuncTGFileInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGFileDialog),sizeof(TGFileDialog),-1,65280,"File selection dialog",G__setup_memvarTGFileDialog,G__setup_memfuncTGFileDialog);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGStatusBarPart);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGStatusBar),sizeof(TGStatusBar),-1,65280,"Status bar widget",G__setup_memvarTGStatusBar,G__setup_memfuncTGStatusBar);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGLabel);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TBox);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_ToolBarData_t),sizeof(ToolBarData_t),-1,0,(char*)NULL,G__setup_memvarToolBarData_t,G__setup_memfuncToolBarData_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGToolBar),sizeof(TGToolBar),-1,65280,"A bar containing picture buttons",G__setup_memvarTGToolBar,G__setup_memfuncTGToolBar);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListTreeItem),sizeof(TGListTreeItem),-1,3854,"Abstract base-class for items that go into a TGListTree container.",G__setup_memvarTGListTreeItem,G__setup_memfuncTGListTreeItem);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListTree),sizeof(TGListTree),-1,65280,"Show items in a tree structured list",G__setup_memvarTGListTree,G__setup_memfuncTGListTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListTreeItemStd),sizeof(TGListTreeItemStd),-1,3840,"Item that goes into a TGListTree container",G__setup_memvarTGListTreeItemStd,G__setup_memfuncTGListTreeItemStd);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListTreecLcLEColorMarkupMode);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGListTreecLcLECheckMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextLine),sizeof(TGTextLine),-1,36608,"Line in TGText",G__setup_memvarTGTextLine,G__setup_memfuncTGTextLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGText),sizeof(TGText),-1,36608,"Text used by TGTextEdit",G__setup_memvarTGText,G__setup_memfuncTGText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGViewFrame),sizeof(TGViewFrame),-1,64000,"Frame containing the actual text",G__setup_memvarTGViewFrame,G__setup_memfuncTGViewFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGView),sizeof(TGView),-1,65280,"View widget base class",G__setup_memvarTGView,G__setup_memfuncTGView);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGViewcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TViewTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextView),sizeof(TGTextView),-1,65280,"Non-editable text viewer widget",G__setup_memvarTGTextView,G__setup_memfuncTGTextView);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGSearchType),sizeof(TGSearchType),-1,1280,(char*)NULL,G__setup_memvarTGSearchType,G__setup_memfuncTGSearchType);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextEditHist);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextEdit),sizeof(TGTextEdit),-1,65280,"Text edit widget",G__setup_memvarTGTextEdit,G__setup_memfuncTGTextEdit);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextEditcLcLEInsertMode);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTextEditcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGIcon);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGSearchDialog),sizeof(TGSearchDialog),-1,62720,"Text search dialog used by TGTextEdit widget",G__setup_memvarTGSearchDialog,G__setup_memfuncTGSearchDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGPrintDialog),sizeof(TGPrintDialog),-1,62720,"Print dialog used by TGTextEdit widget",G__setup_memvarTGPrintDialog,G__setup_memfuncTGPrintDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGGotoDialog),sizeof(TGGotoDialog),-1,62720,"Goto line dialog used by TGTextEdit widget",G__setup_memvarTGGotoDialog,G__setup_memfuncTGGotoDialog);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_EDoubleSliderScale),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGDoubleSlider),sizeof(TGDoubleSlider),-1,65282,"Double slider widget abstract base class",G__setup_memvarTGDoubleSlider,G__setup_memfuncTGDoubleSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGDoubleVSlider),sizeof(TGDoubleVSlider),-1,62720,"Vertical double slider widget",G__setup_memvarTGDoubleVSlider,G__setup_memfuncTGDoubleVSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGDoubleHSlider),sizeof(TGDoubleHSlider),-1,62720,"Horizontal double slider widget",G__setup_memvarTGDoubleHSlider,G__setup_memfuncTGDoubleHSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTreeLBEntry),sizeof(TGTreeLBEntry),-1,62720,"TGFSComboBox entry",G__setup_memvarTGTreeLBEntry,G__setup_memfuncTGTreeLBEntry);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGRegionData);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TArrayS);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGRegion),sizeof(TGRegion),-1,65280,"Describes a region",G__setup_memvarTGRegion,G__setup_memfuncTGRegion);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGRegioncLcLERegionType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGRegionWithId),sizeof(TGRegionWithId),-1,65280,"Region with id, tooltip text and popup menu",G__setup_memvarTGRegionWithId,G__setup_memfuncTGRegionWithId);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGImageMap),sizeof(TGImageMap),-1,65280,"Clickable image (like MAP in HTML)",G__setup_memvarTGImageMap,G__setup_memfuncTGImageMap);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGImageMapcLcLENavMode);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TApplication);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGApplication),sizeof(TGApplication),-1,62720,"GUI application singleton",G__setup_memvarTGApplication,G__setup_memfuncTGApplication);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGXYLayoutHints),sizeof(TGXYLayoutHints),-1,61440,"Hits for the X / Y - layout manager",G__setup_memvarTGXYLayoutHints,G__setup_memfuncTGXYLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGXYLayoutHintscLcLERubberFlag);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGXYLayout),sizeof(TGXYLayout),-1,64000,"X / Y - layout manager",G__setup_memvarTGXYLayout,G__setup_memfuncTGXYLayout);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTripleVSlider),sizeof(TGTripleVSlider),-1,62720,"Vertical triple slider widget",G__setup_memvarTGTripleVSlider,G__setup_memfuncTGTripleVSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Gui2LN_TGTripleHSlider),sizeof(TGTripleHSlider),-1,62720,"Horizontal triple slider widget",G__setup_memvarTGTripleHSlider,G__setup_memfuncTGTripleHSlider);
}
extern "C" void G__cpp_setupG__Gui2(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Gui2()");
  G__set_cpp_environmentG__Gui2();
  G__cpp_setup_tagtableG__Gui2();

  G__cpp_setup_inheritanceG__Gui2();

  G__cpp_setup_typetableG__Gui2();

  G__cpp_setup_memvarG__Gui2();

  G__cpp_setup_memfuncG__Gui2();
  G__cpp_setup_globalG__Gui2();
  G__cpp_setup_funcG__Gui2();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Gui2();
  return;
}
class G__cpp_setup_initG__Gui2 {
  public:
    G__cpp_setup_initG__Gui2() { G__add_setup_func("G__Gui2",(G__incsetup)(&G__cpp_setupG__Gui2)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Gui2() { G__remove_setup_func("G__Gui2"); }
};
G__cpp_setup_initG__Gui2 G__cpp_setup_initializerG__Gui2;

---