G__GL.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:49:45 2011

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

#define R__DICTIONARY_FILENAME graf3ddIgldIsrcdIG__GL
#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__GL.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TGLScene TGLScene;
      #else
      class TGLScene  :  public ::TGLSceneBase {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TGLScene::TSceneInfo TSceneInfo;
         #else
         class TSceneInfo  :  public ::TGLSceneInfo {
            public:
            //friend XX;
            // To force the creation of a virtual table, throw just in case.
            virtual ~TSceneInfo() throw() {};
            ::TGLScene::ShapeVec_t fShapesOfInterest; //
            ::TGLScene::DrawElementVec_t fVisibleElements; //
            unsigned int fMinorStamp; //
            ::TGLScene::DrawElementPtrVec_t fOpaqueElements; //
            ::TGLScene::DrawElementPtrVec_t fTranspElements; //
            ::TGLScene::DrawElementPtrVec_t fSelOpaqueElements; //
            ::TGLScene::DrawElementPtrVec_t fSelTranspElements; //
            int fOpaqueCnt; //
            int fTranspCnt; //
            int fAsPixelCnt; //
            map< ::TClass*, UInt_t > fByShapeCnt; //
         };
         #endif

         typedef ::std::map< ::TObject*, ::TGLLogicalShape*, ::less< ::TObject*>, ::allocator< ::pair< ::TObject* const, ::TGLLogicalShape*> > > LogicalShapeMap_t;
         typedef ::std::pair< ::TObject*, ::TGLLogicalShape*> LogicalShapeMapValueType_t;
         typedef ::std::map< ::TObject*, ::TGLLogicalShape*, ::less< ::TObject*>, ::allocator< ::pair< ::TObject* const, ::TGLLogicalShape*> > >::iterator LogicalShapeMapIt_t;
         typedef ::std::map< ::TObject*, ::TGLLogicalShape*, ::less< ::TObject*>, ::allocator< ::pair< ::TObject* const, ::TGLLogicalShape*> > >::iterator LogicalShapeMapCIt_t;
         typedef ::std::map<unsigned int, ::TGLPhysicalShape*, ::less<unsigned int>, ::allocator< ::pair<const unsigned int, ::TGLPhysicalShape*> > > PhysicalShapeMap_t;
         typedef ::std::pair<unsigned int, ::TGLPhysicalShape*> PhysicalShapeMapValueType_t;
         typedef ::std::map<unsigned int, ::TGLPhysicalShape*, ::less<unsigned int>, ::allocator< ::pair<const unsigned int, ::TGLPhysicalShape*> > >::iterator PhysicalShapeMapIt_t;
         typedef ::std::map<unsigned int, ::TGLPhysicalShape*, ::less<unsigned int>, ::allocator< ::pair<const unsigned int, ::TGLPhysicalShape*> > >::iterator PhysicalShapeMapCIt_t;
         typedef ::std::vector< ::TGLScene::DrawElement_t, ::allocator< ::TGLScene::DrawElement_t> > DrawElementVec_t;
         typedef ::std::vector< ::TGLScene::DrawElement_t, ::allocator< ::TGLScene::DrawElement_t> >::iterator DrawElementVec_i;
         typedef ::std::vector< ::TGLScene::DrawElement_t*, ::allocator< ::TGLScene::DrawElement_t*> > DrawElementPtrVec_t;
         typedef ::std::vector< ::TGLScene::DrawElement_t*, ::allocator< ::TGLScene::DrawElement_t*> >::iterator DrawElementPtrVec_i;
         typedef ::std::vector<const  ::TGLPhysicalShape*, ::allocator<const  ::TGLPhysicalShape*> > ShapeVec_t;
         typedef ::std::vector<const  ::TGLPhysicalShape*, ::allocator<const  ::TGLPhysicalShape*> >::iterator ShapeVec_i;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TGLScene() throw() {};
      };
      #endif

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

namespace ROOT {
   void TArcBall_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArcBall(void *p = 0);
   static void *newArray_TArcBall(Long_t size, void *p);
   static void delete_TArcBall(void *p);
   static void deleteArray_TArcBall(void *p);
   static void destruct_TArcBall(void *p);
   static void streamer_TArcBall(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArcBall*)
   {
      ::TArcBall *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArcBall >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArcBall", ::TArcBall::Class_Version(), "include/TArcBall.h", 21,
                  typeid(::TArcBall), DefineBehavior(ptr, ptr),
                  &::TArcBall::Dictionary, isa_proxy, 0,
                  sizeof(::TArcBall) );
      instance.SetNew(&new_TArcBall);
      instance.SetNewArray(&newArray_TArcBall);
      instance.SetDelete(&delete_TArcBall);
      instance.SetDeleteArray(&deleteArray_TArcBall);
      instance.SetDestructor(&destruct_TArcBall);
      instance.SetStreamerFunc(&streamer_TArcBall);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArcBall*)
   {
      return GenerateInitInstanceLocal((::TArcBall*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArcBall*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLBoundingBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLBoundingBox(void *p = 0);
   static void *newArray_TGLBoundingBox(Long_t size, void *p);
   static void delete_TGLBoundingBox(void *p);
   static void deleteArray_TGLBoundingBox(void *p);
   static void destruct_TGLBoundingBox(void *p);
   static void streamer_TGLBoundingBox(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLCamera_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLCamera(void *p);
   static void deleteArray_TGLCamera(void *p);
   static void destruct_TGLCamera(void *p);
   static void streamer_TGLCamera(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLVector3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLVector3(void *p = 0);
   static void *newArray_TGLVector3(Long_t size, void *p);
   static void delete_TGLVector3(void *p);
   static void deleteArray_TGLVector3(void *p);
   static void destruct_TGLVector3(void *p);
   static void streamer_TGLVector3(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLVector3*)
   {
      ::TGLVector3 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLVector3 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLVector3", ::TGLVector3::Class_Version(), "include/TGLUtil.h", 268,
                  typeid(::TGLVector3), DefineBehavior(ptr, ptr),
                  &::TGLVector3::Dictionary, isa_proxy, 0,
                  sizeof(::TGLVector3) );
      instance.SetNew(&new_TGLVector3);
      instance.SetNewArray(&newArray_TGLVector3);
      instance.SetDelete(&delete_TGLVector3);
      instance.SetDeleteArray(&deleteArray_TGLVector3);
      instance.SetDestructor(&destruct_TGLVector3);
      instance.SetStreamerFunc(&streamer_TGLVector3);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLVector3*)
   {
      return GenerateInitInstanceLocal((::TGLVector3*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLVector3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLVertex3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLVertex3(void *p = 0);
   static void *newArray_TGLVertex3(Long_t size, void *p);
   static void delete_TGLVertex3(void *p);
   static void deleteArray_TGLVertex3(void *p);
   static void destruct_TGLVertex3(void *p);
   static void streamer_TGLVertex3(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLVertex3*)
   {
      ::TGLVertex3 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLVertex3 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLVertex3", ::TGLVertex3::Class_Version(), "include/TGLUtil.h", 104,
                  typeid(::TGLVertex3), DefineBehavior(ptr, ptr),
                  &::TGLVertex3::Dictionary, isa_proxy, 0,
                  sizeof(::TGLVertex3) );
      instance.SetNew(&new_TGLVertex3);
      instance.SetNewArray(&newArray_TGLVertex3);
      instance.SetDelete(&delete_TGLVertex3);
      instance.SetDeleteArray(&deleteArray_TGLVertex3);
      instance.SetDestructor(&destruct_TGLVertex3);
      instance.SetStreamerFunc(&streamer_TGLVertex3);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLVertex3*)
   {
      return GenerateInitInstanceLocal((::TGLVertex3*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLVertex3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLLine3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLLine3(void *p);
   static void deleteArray_TGLLine3(void *p);
   static void destruct_TGLLine3(void *p);
   static void streamer_TGLLine3(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLRect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLRect(void *p = 0);
   static void *newArray_TGLRect(Long_t size, void *p);
   static void delete_TGLRect(void *p);
   static void deleteArray_TGLRect(void *p);
   static void destruct_TGLRect(void *p);
   static void streamer_TGLRect(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLRect*)
   {
      ::TGLRect *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLRect >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLRect", ::TGLRect::Class_Version(), "include/TGLUtil.h", 444,
                  typeid(::TGLRect), DefineBehavior(ptr, ptr),
                  &::TGLRect::Dictionary, isa_proxy, 0,
                  sizeof(::TGLRect) );
      instance.SetNew(&new_TGLRect);
      instance.SetNewArray(&newArray_TGLRect);
      instance.SetDelete(&delete_TGLRect);
      instance.SetDeleteArray(&deleteArray_TGLRect);
      instance.SetDestructor(&destruct_TGLRect);
      instance.SetStreamerFunc(&streamer_TGLRect);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLRect*)
   {
      return GenerateInitInstanceLocal((::TGLRect*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLRect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLPlane_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPlane(void *p = 0);
   static void *newArray_TGLPlane(Long_t size, void *p);
   static void delete_TGLPlane(void *p);
   static void deleteArray_TGLPlane(void *p);
   static void destruct_TGLPlane(void *p);
   static void streamer_TGLPlane(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLPlane*)
   {
      ::TGLPlane *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLPlane >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLPlane", ::TGLPlane::Class_Version(), "include/TGLUtil.h", 547,
                  typeid(::TGLPlane), DefineBehavior(ptr, ptr),
                  &::TGLPlane::Dictionary, isa_proxy, 0,
                  sizeof(::TGLPlane) );
      instance.SetNew(&new_TGLPlane);
      instance.SetNewArray(&newArray_TGLPlane);
      instance.SetDelete(&delete_TGLPlane);
      instance.SetDeleteArray(&deleteArray_TGLPlane);
      instance.SetDestructor(&destruct_TGLPlane);
      instance.SetStreamerFunc(&streamer_TGLPlane);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLPlane*)
   {
      return GenerateInitInstanceLocal((::TGLPlane*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLPlane*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLMatrix_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLMatrix(void *p = 0);
   static void *newArray_TGLMatrix(Long_t size, void *p);
   static void delete_TGLMatrix(void *p);
   static void deleteArray_TGLMatrix(void *p);
   static void destruct_TGLMatrix(void *p);
   static void streamer_TGLMatrix(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLMatrix*)
   {
      ::TGLMatrix *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLMatrix >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLMatrix", ::TGLMatrix::Class_Version(), "include/TGLUtil.h", 618,
                  typeid(::TGLMatrix), DefineBehavior(ptr, ptr),
                  &::TGLMatrix::Dictionary, isa_proxy, 0,
                  sizeof(::TGLMatrix) );
      instance.SetNew(&new_TGLMatrix);
      instance.SetNewArray(&newArray_TGLMatrix);
      instance.SetDelete(&delete_TGLMatrix);
      instance.SetDeleteArray(&deleteArray_TGLMatrix);
      instance.SetDestructor(&destruct_TGLMatrix);
      instance.SetStreamerFunc(&streamer_TGLMatrix);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLMatrix*)
   {
      return GenerateInitInstanceLocal((::TGLMatrix*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLMatrix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLColor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLColor(void *p = 0);
   static void *newArray_TGLColor(Long_t size, void *p);
   static void delete_TGLColor(void *p);
   static void deleteArray_TGLColor(void *p);
   static void destruct_TGLColor(void *p);
   static void streamer_TGLColor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLColor*)
   {
      ::TGLColor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLColor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLColor", ::TGLColor::Class_Version(), "include/TGLUtil.h", 804,
                  typeid(::TGLColor), DefineBehavior(ptr, ptr),
                  &::TGLColor::Dictionary, isa_proxy, 0,
                  sizeof(::TGLColor) );
      instance.SetNew(&new_TGLColor);
      instance.SetNewArray(&newArray_TGLColor);
      instance.SetDelete(&delete_TGLColor);
      instance.SetDeleteArray(&deleteArray_TGLColor);
      instance.SetDestructor(&destruct_TGLColor);
      instance.SetStreamerFunc(&streamer_TGLColor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLColor*)
   {
      return GenerateInitInstanceLocal((::TGLColor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLColor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLColorSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLColorSet(void *p = 0);
   static void *newArray_TGLColorSet(Long_t size, void *p);
   static void delete_TGLColorSet(void *p);
   static void deleteArray_TGLColorSet(void *p);
   static void destruct_TGLColorSet(void *p);
   static void streamer_TGLColorSet(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLColorSet*)
   {
      ::TGLColorSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLColorSet >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLColorSet", ::TGLColorSet::Class_Version(), "include/TGLUtil.h", 855,
                  typeid(::TGLColorSet), DefineBehavior(ptr, ptr),
                  &::TGLColorSet::Dictionary, isa_proxy, 0,
                  sizeof(::TGLColorSet) );
      instance.SetNew(&new_TGLColorSet);
      instance.SetNewArray(&newArray_TGLColorSet);
      instance.SetDelete(&delete_TGLColorSet);
      instance.SetDeleteArray(&deleteArray_TGLColorSet);
      instance.SetDestructor(&destruct_TGLColorSet);
      instance.SetStreamerFunc(&streamer_TGLColorSet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLColorSet*)
   {
      return GenerateInitInstanceLocal((::TGLColorSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLColorSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLUtil_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLUtil(void *p);
   static void deleteArray_TGLUtil(void *p);
   static void destruct_TGLUtil(void *p);
   static void streamer_TGLUtil(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLUtilcLcLTColorLocker_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLUtilcLcLTColorLocker(void *p = 0);
   static void *newArray_TGLUtilcLcLTColorLocker(Long_t size, void *p);
   static void delete_TGLUtilcLcLTColorLocker(void *p);
   static void deleteArray_TGLUtilcLcLTColorLocker(void *p);
   static void destruct_TGLUtilcLcLTColorLocker(void *p);
   static void streamer_TGLUtilcLcLTColorLocker(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLUtil::TColorLocker*)
   {
      ::TGLUtil::TColorLocker *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLUtil::TColorLocker >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLUtil::TColorLocker", ::TGLUtil::TColorLocker::Class_Version(), "include/TGLUtil.h", 900,
                  typeid(::TGLUtil::TColorLocker), DefineBehavior(ptr, ptr),
                  &::TGLUtil::TColorLocker::Dictionary, isa_proxy, 0,
                  sizeof(::TGLUtil::TColorLocker) );
      instance.SetNew(&new_TGLUtilcLcLTColorLocker);
      instance.SetNewArray(&newArray_TGLUtilcLcLTColorLocker);
      instance.SetDelete(&delete_TGLUtilcLcLTColorLocker);
      instance.SetDeleteArray(&deleteArray_TGLUtilcLcLTColorLocker);
      instance.SetDestructor(&destruct_TGLUtilcLcLTColorLocker);
      instance.SetStreamerFunc(&streamer_TGLUtilcLcLTColorLocker);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLUtil::TColorLocker*)
   {
      return GenerateInitInstanceLocal((::TGLUtil::TColorLocker*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLUtil::TColorLocker*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLUtilcLcLTDrawQualityModifier_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLUtilcLcLTDrawQualityModifier(void *p);
   static void deleteArray_TGLUtilcLcLTDrawQualityModifier(void *p);
   static void destruct_TGLUtilcLcLTDrawQualityModifier(void *p);
   static void streamer_TGLUtilcLcLTDrawQualityModifier(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLUtilcLcLTDrawQualityScaler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLUtilcLcLTDrawQualityScaler(void *p);
   static void deleteArray_TGLUtilcLcLTDrawQualityScaler(void *p);
   static void destruct_TGLUtilcLcLTDrawQualityScaler(void *p);
   static void streamer_TGLUtilcLcLTDrawQualityScaler(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLSelectionBuffer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLSelectionBuffer(void *p = 0);
   static void *newArray_TGLSelectionBuffer(Long_t size, void *p);
   static void delete_TGLSelectionBuffer(void *p);
   static void deleteArray_TGLSelectionBuffer(void *p);
   static void destruct_TGLSelectionBuffer(void *p);
   static void streamer_TGLSelectionBuffer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLSelectionBuffer*)
   {
      ::TGLSelectionBuffer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLSelectionBuffer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLSelectionBuffer", ::TGLSelectionBuffer::Class_Version(), "include/TGLUtil.h", 1129,
                  typeid(::TGLSelectionBuffer), DefineBehavior(ptr, ptr),
                  &::TGLSelectionBuffer::Dictionary, isa_proxy, 0,
                  sizeof(::TGLSelectionBuffer) );
      instance.SetNew(&new_TGLSelectionBuffer);
      instance.SetNewArray(&newArray_TGLSelectionBuffer);
      instance.SetDelete(&delete_TGLSelectionBuffer);
      instance.SetDeleteArray(&deleteArray_TGLSelectionBuffer);
      instance.SetDestructor(&destruct_TGLSelectionBuffer);
      instance.SetStreamerFunc(&streamer_TGLSelectionBuffer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLSelectionBuffer*)
   {
      return GenerateInitInstanceLocal((::TGLSelectionBuffer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLSelectionBuffer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLPlotCoordinates_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPlotCoordinates(void *p = 0);
   static void *newArray_TGLPlotCoordinates(Long_t size, void *p);
   static void delete_TGLPlotCoordinates(void *p);
   static void deleteArray_TGLPlotCoordinates(void *p);
   static void destruct_TGLPlotCoordinates(void *p);
   static void streamer_TGLPlotCoordinates(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLPlotCoordinates*)
   {
      ::TGLPlotCoordinates *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLPlotCoordinates >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLPlotCoordinates", ::TGLPlotCoordinates::Class_Version(), "include/TGLPlotPainter.h", 308,
                  typeid(::TGLPlotCoordinates), DefineBehavior(ptr, ptr),
                  &::TGLPlotCoordinates::Dictionary, isa_proxy, 0,
                  sizeof(::TGLPlotCoordinates) );
      instance.SetNew(&new_TGLPlotCoordinates);
      instance.SetNewArray(&newArray_TGLPlotCoordinates);
      instance.SetDelete(&delete_TGLPlotCoordinates);
      instance.SetDeleteArray(&deleteArray_TGLPlotCoordinates);
      instance.SetDestructor(&destruct_TGLPlotCoordinates);
      instance.SetStreamerFunc(&streamer_TGLPlotCoordinates);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLPlotCoordinates*)
   {
      return GenerateInitInstanceLocal((::TGLPlotCoordinates*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLPlotCoordinates*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLQuadric_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLQuadric(void *p = 0);
   static void *newArray_TGLQuadric(Long_t size, void *p);
   static void delete_TGLQuadric(void *p);
   static void deleteArray_TGLQuadric(void *p);
   static void destruct_TGLQuadric(void *p);
   static void streamer_TGLQuadric(TBuffer &buf, void *obj);

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

namespace Rgl {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void Rgl_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("Rgl", 0 /*version*/, "include/TGLIsoMesh.h", 26,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &Rgl_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void Rgl_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOT {
   void TGLPhysicalShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPhysicalShape(void *p);
   static void deleteArray_TGLPhysicalShape(void *p);
   static void destruct_TGLPhysicalShape(void *p);
   static void streamer_TGLPhysicalShape(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLRnrCtx_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLRnrCtx(void *p);
   static void deleteArray_TGLRnrCtx(void *p);
   static void destruct_TGLRnrCtx(void *p);

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

namespace ROOT {
   void TGLSelectRecord_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLSelectRecord(void *p = 0);
   static void *newArray_TGLSelectRecord(Long_t size, void *p);
   static void delete_TGLSelectRecord(void *p);
   static void deleteArray_TGLSelectRecord(void *p);
   static void destruct_TGLSelectRecord(void *p);

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

namespace ROOT {
   void TGLViewer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLViewer(void *p);
   static void deleteArray_TGLViewer(void *p);
   static void destruct_TGLViewer(void *p);

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

namespace ROOT {
   void TGLSceneBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLSceneBase(void *p);
   static void deleteArray_TGLSceneBase(void *p);
   static void destruct_TGLSceneBase(void *p);

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

namespace ROOT {
   void TGLScene_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLScene(void *p = 0);
   static void *newArray_TGLScene(Long_t size, void *p);
   static void delete_TGLScene(void *p);
   static void deleteArray_TGLScene(void *p);
   static void destruct_TGLScene(void *p);

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

namespace ROOT {
   void TGLLogicalShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLLogicalShape(void *p);
   static void deleteArray_TGLLogicalShape(void *p);
   static void destruct_TGLLogicalShape(void *p);
   static void streamer_TGLLogicalShape(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLObject(void *p);
   static void deleteArray_TGLObject(void *p);
   static void destruct_TGLObject(void *p);

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

namespace ROOT {
   void TGLManip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLManip(void *p);
   static void deleteArray_TGLManip(void *p);
   static void destruct_TGLManip(void *p);
   static void streamer_TGLManip(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLContext_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLContext(void *p);
   static void deleteArray_TGLContext(void *p);
   static void destruct_TGLContext(void *p);
   static void streamer_TGLContext(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLFormat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLFormat(void *p = 0);
   static void *newArray_TGLFormat(Long_t size, void *p);
   static void delete_TGLFormat(void *p);
   static void deleteArray_TGLFormat(void *p);
   static void destruct_TGLFormat(void *p);
   static void streamer_TGLFormat(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPlotBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPlotBox(void *p);
   static void deleteArray_TGLPlotBox(void *p);
   static void destruct_TGLPlotBox(void *p);
   static void streamer_TGLPlotBox(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPlotCamera_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPlotCamera(void *p = 0);
   static void *newArray_TGLPlotCamera(Long_t size, void *p);
   static void delete_TGLPlotCamera(void *p);
   static void deleteArray_TGLPlotCamera(void *p);
   static void destruct_TGLPlotCamera(void *p);

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

namespace ROOT {
   void TGL5DDataSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGL5DDataSet(void *p);
   static void deleteArray_TGL5DDataSet(void *p);
   static void destruct_TGL5DDataSet(void *p);
   static void streamer_TGL5DDataSet(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLBoxCut_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLBoxCut(void *p);
   static void deleteArray_TGLBoxCut(void *p);
   static void destruct_TGLBoxCut(void *p);
   static void streamer_TGLBoxCut(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLTH3Slice_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLTH3Slice(void *p);
   static void deleteArray_TGLTH3Slice(void *p);
   static void destruct_TGLTH3Slice(void *p);
   static void streamer_TGLTH3Slice(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPlotPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPlotPainter(void *p);
   static void deleteArray_TGLPlotPainter(void *p);
   static void destruct_TGLPlotPainter(void *p);
   static void streamer_TGLPlotPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPlot3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPlot3D(void *p);
   static void deleteArray_TGLPlot3D(void *p);
   static void destruct_TGLPlot3D(void *p);

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

namespace ROOT {
   void TF2GL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TF2GL(void *p = 0);
   static void *newArray_TF2GL(Long_t size, void *p);
   static void delete_TF2GL(void *p);
   static void deleteArray_TF2GL(void *p);
   static void destruct_TF2GL(void *p);

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

namespace ROOT {
   void TGL5DDataSetEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGL5DDataSetEditor(void *p = 0);
   static void *newArray_TGL5DDataSetEditor(Long_t size, void *p);
   static void delete_TGL5DDataSetEditor(void *p);
   static void deleteArray_TGL5DDataSetEditor(void *p);
   static void destruct_TGL5DDataSetEditor(void *p);
   static void streamer_TGL5DDataSetEditor(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLParametricEquation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLParametricEquation(void *p);
   static void deleteArray_TGLParametricEquation(void *p);
   static void destruct_TGLParametricEquation(void *p);
   static void streamer_TGLParametricEquation(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLTH3Composition_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLTH3Composition(void *p = 0);
   static void *newArray_TGLTH3Composition(Long_t size, void *p);
   static void delete_TGLTH3Composition(void *p);
   static void deleteArray_TGLTH3Composition(void *p);
   static void destruct_TGLTH3Composition(void *p);
   static void directoryAutoAdd_TGLTH3Composition(void *p, TDirectory *dir);
   static void streamer_TGLTH3Composition(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLTH3Composition*)
   {
      ::TGLTH3Composition *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLTH3Composition >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLTH3Composition", ::TGLTH3Composition::Class_Version(), "include/TGLTH3Composition.h", 35,
                  typeid(::TGLTH3Composition), DefineBehavior(ptr, ptr),
                  &::TGLTH3Composition::Dictionary, isa_proxy, 0,
                  sizeof(::TGLTH3Composition) );
      instance.SetNew(&new_TGLTH3Composition);
      instance.SetNewArray(&newArray_TGLTH3Composition);
      instance.SetDelete(&delete_TGLTH3Composition);
      instance.SetDeleteArray(&deleteArray_TGLTH3Composition);
      instance.SetDestructor(&destruct_TGLTH3Composition);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TGLTH3Composition);
      instance.SetStreamerFunc(&streamer_TGLTH3Composition);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLTH3Composition*)
   {
      return GenerateInitInstanceLocal((::TGLTH3Composition*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLTH3Composition*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLHistPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLHistPainter(void *p);
   static void deleteArray_TGLHistPainter(void *p);
   static void destruct_TGLHistPainter(void *p);
   static void streamer_TGLHistPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLAdapter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLAdapter(void *p = 0);
   static void *newArray_TGLAdapter(Long_t size, void *p);
   static void delete_TGLAdapter(void *p);
   static void deleteArray_TGLAdapter(void *p);
   static void destruct_TGLAdapter(void *p);
   static void streamer_TGLAdapter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLAdapter*)
   {
      ::TGLAdapter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLAdapter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLAdapter", ::TGLAdapter::Class_Version(), "include/TGLAdapter.h", 19,
                  typeid(::TGLAdapter), DefineBehavior(ptr, ptr),
                  &::TGLAdapter::Dictionary, isa_proxy, 0,
                  sizeof(::TGLAdapter) );
      instance.SetNew(&new_TGLAdapter);
      instance.SetNewArray(&newArray_TGLAdapter);
      instance.SetDelete(&delete_TGLAdapter);
      instance.SetDeleteArray(&deleteArray_TGLAdapter);
      instance.SetDestructor(&destruct_TGLAdapter);
      instance.SetStreamerFunc(&streamer_TGLAdapter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLAdapter*)
   {
      return GenerateInitInstanceLocal((::TGLAdapter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLAdapter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLOvlSelectRecord_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLOvlSelectRecord(void *p = 0);
   static void *newArray_TGLOvlSelectRecord(Long_t size, void *p);
   static void delete_TGLOvlSelectRecord(void *p);
   static void deleteArray_TGLOvlSelectRecord(void *p);
   static void destruct_TGLOvlSelectRecord(void *p);

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

namespace ROOT {
   void TGLOverlayElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLOverlayElement(void *p);
   static void deleteArray_TGLOverlayElement(void *p);
   static void destruct_TGLOverlayElement(void *p);

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

namespace ROOT {
   void TGLOverlayList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLOverlayList(void *p = 0);
   static void *newArray_TGLOverlayList(Long_t size, void *p);
   static void delete_TGLOverlayList(void *p);
   static void deleteArray_TGLOverlayList(void *p);
   static void destruct_TGLOverlayList(void *p);

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

namespace ROOT {
   void TGLFontManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLFontManager(void *p = 0);
   static void *newArray_TGLFontManager(Long_t size, void *p);
   static void delete_TGLFontManager(void *p);
   static void deleteArray_TGLFontManager(void *p);
   static void destruct_TGLFontManager(void *p);
   static void streamer_TGLFontManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLFont_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLFont(void *p = 0);
   static void *newArray_TGLFont(Long_t size, void *p);
   static void delete_TGLFont(void *p);
   static void deleteArray_TGLFont(void *p);
   static void destruct_TGLFont(void *p);
   static void streamer_TGLFont(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLFont*)
   {
      ::TGLFont *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLFont >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLFont", ::TGLFont::Class_Version(), "include/TGLFontManager.h", 24,
                  typeid(::TGLFont), DefineBehavior(ptr, ptr),
                  &::TGLFont::Dictionary, isa_proxy, 0,
                  sizeof(::TGLFont) );
      instance.SetNew(&new_TGLFont);
      instance.SetNewArray(&newArray_TGLFont);
      instance.SetDelete(&delete_TGLFont);
      instance.SetDeleteArray(&deleteArray_TGLFont);
      instance.SetDestructor(&destruct_TGLFont);
      instance.SetStreamerFunc(&streamer_TGLFont);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLFont*)
   {
      return GenerateInitInstanceLocal((::TGLFont*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLFont*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLViewerBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLViewerBase(void *p = 0);
   static void *newArray_TGLViewerBase(Long_t size, void *p);
   static void delete_TGLViewerBase(void *p);
   static void deleteArray_TGLViewerBase(void *p);
   static void destruct_TGLViewerBase(void *p);

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

namespace ROOT {
   void TGLAnnotation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLAnnotation(void *p);
   static void deleteArray_TGLAnnotation(void *p);
   static void destruct_TGLAnnotation(void *p);

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

namespace ROOT {
   void TGLAutoRotator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLAutoRotator(void *p);
   static void deleteArray_TGLAutoRotator(void *p);
   static void destruct_TGLAutoRotator(void *p);

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

namespace ROOT {
   void TGLText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLText(void *p = 0);
   static void *newArray_TGLText(Long_t size, void *p);
   static void delete_TGLText(void *p);
   static void deleteArray_TGLText(void *p);
   static void destruct_TGLText(void *p);
   static void streamer_TGLText(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLText*)
   {
      ::TGLText *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLText >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLText", ::TGLText::Class_Version(), "include/TGLText.h", 21,
                  typeid(::TGLText), DefineBehavior(ptr, ptr),
                  &::TGLText::Dictionary, isa_proxy, 0,
                  sizeof(::TGLText) );
      instance.SetNew(&new_TGLText);
      instance.SetNewArray(&newArray_TGLText);
      instance.SetDelete(&delete_TGLText);
      instance.SetDeleteArray(&deleteArray_TGLText);
      instance.SetDestructor(&destruct_TGLText);
      instance.SetStreamerFunc(&streamer_TGLText);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLText*)
   {
      return GenerateInitInstanceLocal((::TGLText*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLText*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLAxis_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLAxis(void *p = 0);
   static void *newArray_TGLAxis(Long_t size, void *p);
   static void delete_TGLAxis(void *p);
   static void deleteArray_TGLAxis(void *p);
   static void destruct_TGLAxis(void *p);
   static void streamer_TGLAxis(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLAxis*)
   {
      ::TGLAxis *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLAxis >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLAxis", ::TGLAxis::Class_Version(), "include/TGLAxis.h", 26,
                  typeid(::TGLAxis), DefineBehavior(ptr, ptr),
                  &::TGLAxis::Dictionary, isa_proxy, 0,
                  sizeof(::TGLAxis) );
      instance.SetNew(&new_TGLAxis);
      instance.SetNewArray(&newArray_TGLAxis);
      instance.SetDelete(&delete_TGLAxis);
      instance.SetDeleteArray(&deleteArray_TGLAxis);
      instance.SetDestructor(&destruct_TGLAxis);
      instance.SetStreamerFunc(&streamer_TGLAxis);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLAxis*)
   {
      return GenerateInitInstanceLocal((::TGLAxis*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLAxis*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLAxisPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLAxisPainter(void *p = 0);
   static void *newArray_TGLAxisPainter(Long_t size, void *p);
   static void delete_TGLAxisPainter(void *p);
   static void deleteArray_TGLAxisPainter(void *p);
   static void destruct_TGLAxisPainter(void *p);

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

namespace ROOT {
   void TGLAxisPainterBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLAxisPainterBox(void *p = 0);
   static void *newArray_TGLAxisPainterBox(Long_t size, void *p);
   static void delete_TGLAxisPainterBox(void *p);
   static void deleteArray_TGLAxisPainterBox(void *p);
   static void destruct_TGLAxisPainterBox(void *p);

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

namespace ROOT {
   void TGLBoxPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLBoxPainter(void *p);
   static void deleteArray_TGLBoxPainter(void *p);
   static void destruct_TGLBoxPainter(void *p);
   static void streamer_TGLBoxPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLCameraGuide_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLCameraGuide(void *p);
   static void deleteArray_TGLCameraGuide(void *p);
   static void destruct_TGLCameraGuide(void *p);
   static void streamer_TGLCameraGuide(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLCameraOverlay_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLCameraOverlay(void *p = 0);
   static void *newArray_TGLCameraOverlay(Long_t size, void *p);
   static void delete_TGLCameraOverlay(void *p);
   static void deleteArray_TGLCameraOverlay(void *p);
   static void destruct_TGLCameraOverlay(void *p);
   static void streamer_TGLCameraOverlay(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLCameraOverlay*)
   {
      ::TGLCameraOverlay *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLCameraOverlay >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLCameraOverlay", ::TGLCameraOverlay::Class_Version(), "include/TGLCameraOverlay.h", 26,
                  typeid(::TGLCameraOverlay), DefineBehavior(ptr, ptr),
                  &::TGLCameraOverlay::Dictionary, isa_proxy, 0,
                  sizeof(::TGLCameraOverlay) );
      instance.SetNew(&new_TGLCameraOverlay);
      instance.SetNewArray(&newArray_TGLCameraOverlay);
      instance.SetDelete(&delete_TGLCameraOverlay);
      instance.SetDeleteArray(&deleteArray_TGLCameraOverlay);
      instance.SetDestructor(&destruct_TGLCameraOverlay);
      instance.SetStreamerFunc(&streamer_TGLCameraOverlay);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLCameraOverlay*)
   {
      return GenerateInitInstanceLocal((::TGLCameraOverlay*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLCameraOverlay*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLPShapeRef_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPShapeRef(void *p = 0);
   static void *newArray_TGLPShapeRef(Long_t size, void *p);
   static void delete_TGLPShapeRef(void *p);
   static void deleteArray_TGLPShapeRef(void *p);
   static void destruct_TGLPShapeRef(void *p);

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

namespace ROOT {
   void TGLManipSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLManipSet(void *p = 0);
   static void *newArray_TGLManipSet(Long_t size, void *p);
   static void delete_TGLManipSet(void *p);
   static void deleteArray_TGLManipSet(void *p);
   static void destruct_TGLManipSet(void *p);
   static void streamer_TGLManipSet(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLManipSet*)
   {
      ::TGLManipSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLManipSet >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLManipSet", ::TGLManipSet::Class_Version(), "include/TGLManipSet.h", 23,
                  typeid(::TGLManipSet), DefineBehavior(ptr, ptr),
                  &::TGLManipSet::Dictionary, isa_proxy, 0,
                  sizeof(::TGLManipSet) );
      instance.SetNew(&new_TGLManipSet);
      instance.SetNewArray(&newArray_TGLManipSet);
      instance.SetDelete(&delete_TGLManipSet);
      instance.SetDeleteArray(&deleteArray_TGLManipSet);
      instance.SetDestructor(&destruct_TGLManipSet);
      instance.SetStreamerFunc(&streamer_TGLManipSet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLManipSet*)
   {
      return GenerateInitInstanceLocal((::TGLManipSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLManipSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLClip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLClip(void *p);
   static void deleteArray_TGLClip(void *p);
   static void destruct_TGLClip(void *p);

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

namespace ROOT {
   void TGLClipPlane_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLClipPlane(void *p = 0);
   static void *newArray_TGLClipPlane(Long_t size, void *p);
   static void delete_TGLClipPlane(void *p);
   static void deleteArray_TGLClipPlane(void *p);
   static void destruct_TGLClipPlane(void *p);

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

namespace ROOT {
   void TGLClipBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLClipBox(void *p = 0);
   static void *newArray_TGLClipBox(Long_t size, void *p);
   static void delete_TGLClipBox(void *p);
   static void deleteArray_TGLClipBox(void *p);
   static void destruct_TGLClipBox(void *p);

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

namespace ROOT {
   void TGLClipSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLClipSet(void *p = 0);
   static void *newArray_TGLClipSet(Long_t size, void *p);
   static void delete_TGLClipSet(void *p);
   static void deleteArray_TGLClipSet(void *p);
   static void destruct_TGLClipSet(void *p);

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

namespace ROOT {
   void TGLClipSetSubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLClipSetSubEditor(void *p);
   static void deleteArray_TGLClipSetSubEditor(void *p);
   static void destruct_TGLClipSetSubEditor(void *p);

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

namespace ROOT {
   void TGLClipSetEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLClipSetEditor(void *p = 0);
   static void *newArray_TGLClipSetEditor(Long_t size, void *p);
   static void delete_TGLClipSetEditor(void *p);
   static void deleteArray_TGLClipSetEditor(void *p);
   static void destruct_TGLClipSetEditor(void *p);

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

namespace ROOT {
   void TGLContextIdentity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLContextIdentity(void *p = 0);
   static void *newArray_TGLContextIdentity(Long_t size, void *p);
   static void delete_TGLContextIdentity(void *p);
   static void deleteArray_TGLContextIdentity(void *p);
   static void destruct_TGLContextIdentity(void *p);
   static void streamer_TGLContextIdentity(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLContextIdentity*)
   {
      ::TGLContextIdentity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLContextIdentity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLContextIdentity", ::TGLContextIdentity::Class_Version(), "include/TGLContext.h", 84,
                  typeid(::TGLContextIdentity), DefineBehavior(ptr, ptr),
                  &::TGLContextIdentity::Dictionary, isa_proxy, 0,
                  sizeof(::TGLContextIdentity) );
      instance.SetNew(&new_TGLContextIdentity);
      instance.SetNewArray(&newArray_TGLContextIdentity);
      instance.SetDelete(&delete_TGLContextIdentity);
      instance.SetDeleteArray(&deleteArray_TGLContextIdentity);
      instance.SetDestructor(&destruct_TGLContextIdentity);
      instance.SetStreamerFunc(&streamer_TGLContextIdentity);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLContextIdentity*)
   {
      return GenerateInitInstanceLocal((::TGLContextIdentity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLContextIdentity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLWidget_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLWidget(void *p);
   static void deleteArray_TGLWidget(void *p);
   static void destruct_TGLWidget(void *p);
   static void streamer_TGLWidget(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLCylinder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLCylinder(void *p);
   static void deleteArray_TGLCylinder(void *p);
   static void destruct_TGLCylinder(void *p);
   static void streamer_TGLCylinder(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLLockable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLLockable(void *p = 0);
   static void *newArray_TGLLockable(Long_t size, void *p);
   static void delete_TGLLockable(void *p);
   static void deleteArray_TGLLockable(void *p);
   static void destruct_TGLLockable(void *p);
   static void streamer_TGLLockable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLLockable*)
   {
      ::TGLLockable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLLockable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLLockable", ::TGLLockable::Class_Version(), "include/TGLLockable.h", 18,
                  typeid(::TGLLockable), DefineBehavior(ptr, ptr),
                  &::TGLLockable::Dictionary, isa_proxy, 0,
                  sizeof(::TGLLockable) );
      instance.SetNew(&new_TGLLockable);
      instance.SetNewArray(&newArray_TGLLockable);
      instance.SetDelete(&delete_TGLLockable);
      instance.SetDeleteArray(&deleteArray_TGLLockable);
      instance.SetDestructor(&destruct_TGLLockable);
      instance.SetStreamerFunc(&streamer_TGLLockable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLLockable*)
   {
      return GenerateInitInstanceLocal((::TGLLockable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLLockable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLSceneInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLSceneInfo(void *p = 0);
   static void *newArray_TGLSceneInfo(Long_t size, void *p);
   static void delete_TGLSceneInfo(void *p);
   static void deleteArray_TGLSceneInfo(void *p);
   static void destruct_TGLSceneInfo(void *p);

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

namespace ROOT {
   void TGLStopwatch_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLStopwatch(void *p = 0);
   static void *newArray_TGLStopwatch(Long_t size, void *p);
   static void delete_TGLStopwatch(void *p);
   static void deleteArray_TGLStopwatch(void *p);
   static void destruct_TGLStopwatch(void *p);
   static void streamer_TGLStopwatch(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLSelectBuffer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLSelectBuffer(void *p = 0);
   static void *newArray_TGLSelectBuffer(Long_t size, void *p);
   static void delete_TGLSelectBuffer(void *p);
   static void deleteArray_TGLSelectBuffer(void *p);
   static void destruct_TGLSelectBuffer(void *p);

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

namespace ROOT {
   void TGLSelectRecordBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLSelectRecordBase(void *p = 0);
   static void *newArray_TGLSelectRecordBase(Long_t size, void *p);
   static void delete_TGLSelectRecordBase(void *p);
   static void deleteArray_TGLSelectRecordBase(void *p);
   static void destruct_TGLSelectRecordBase(void *p);

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

namespace ROOT {
   void TGLPerspectiveCamera_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPerspectiveCamera(void *p);
   static void deleteArray_TGLPerspectiveCamera(void *p);
   static void destruct_TGLPerspectiveCamera(void *p);
   static void streamer_TGLPerspectiveCamera(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLOrthoCamera_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLOrthoCamera(void *p);
   static void deleteArray_TGLOrthoCamera(void *p);
   static void destruct_TGLOrthoCamera(void *p);
   static void streamer_TGLOrthoCamera(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLViewerEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLViewerEditor(void *p = 0);
   static void *newArray_TGLViewerEditor(Long_t size, void *p);
   static void delete_TGLViewerEditor(void *p);
   static void deleteArray_TGLViewerEditor(void *p);
   static void destruct_TGLViewerEditor(void *p);

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

namespace ROOT {
   void TGLLightSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLLightSet(void *p = 0);
   static void *newArray_TGLLightSet(Long_t size, void *p);
   static void delete_TGLLightSet(void *p);
   static void deleteArray_TGLLightSet(void *p);
   static void destruct_TGLLightSet(void *p);

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

namespace ROOT {
   void TGLPShapeObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPShapeObj(void *p = 0);
   static void *newArray_TGLPShapeObj(Long_t size, void *p);
   static void delete_TGLPShapeObj(void *p);
   static void deleteArray_TGLPShapeObj(void *p);
   static void destruct_TGLPShapeObj(void *p);

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

namespace ROOT {
   void TGLOutput_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLOutput(void *p = 0);
   static void *newArray_TGLOutput(Long_t size, void *p);
   static void delete_TGLOutput(void *p);
   static void deleteArray_TGLOutput(void *p);
   static void destruct_TGLOutput(void *p);
   static void streamer_TGLOutput(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLOutput*)
   {
      ::TGLOutput *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLOutput >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLOutput", ::TGLOutput::Class_Version(), "include/TGLOutput.h", 28,
                  typeid(::TGLOutput), DefineBehavior(ptr, ptr),
                  &::TGLOutput::Dictionary, isa_proxy, 0,
                  sizeof(::TGLOutput) );
      instance.SetNew(&new_TGLOutput);
      instance.SetNewArray(&newArray_TGLOutput);
      instance.SetDelete(&delete_TGLOutput);
      instance.SetDeleteArray(&deleteArray_TGLOutput);
      instance.SetDestructor(&destruct_TGLOutput);
      instance.SetStreamerFunc(&streamer_TGLOutput);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLOutput*)
   {
      return GenerateInitInstanceLocal((::TGLOutput*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLOutput*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLEventHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLEventHandler(void *p);
   static void deleteArray_TGLEventHandler(void *p);
   static void destruct_TGLEventHandler(void *p);
   static void streamer_TGLEventHandler(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLFaderHelper_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLFaderHelper(void *p = 0);
   static void *newArray_TGLFaderHelper(Long_t size, void *p);
   static void delete_TGLFaderHelper(void *p);
   static void deleteArray_TGLFaderHelper(void *p);
   static void destruct_TGLFaderHelper(void *p);

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

namespace ROOT {
   void TGLEmbeddedViewer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLEmbeddedViewer(void *p);
   static void deleteArray_TGLEmbeddedViewer(void *p);
   static void destruct_TGLEmbeddedViewer(void *p);
   static void streamer_TGLEmbeddedViewer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLFaceSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLFaceSet(void *p);
   static void deleteArray_TGLFaceSet(void *p);
   static void destruct_TGLFaceSet(void *p);
   static void streamer_TGLFaceSet(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLFBO_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLFBO(void *p = 0);
   static void *newArray_TGLFBO(Long_t size, void *p);
   static void delete_TGLFBO(void *p);
   static void deleteArray_TGLFBO(void *p);
   static void destruct_TGLFBO(void *p);

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

namespace ROOT {
   void TGLPadPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPadPainter(void *p = 0);
   static void *newArray_TGLPadPainter(Long_t size, void *p);
   static void delete_TGLPadPainter(void *p);
   static void deleteArray_TGLPadPainter(void *p);
   static void destruct_TGLPadPainter(void *p);
   static void streamer_TGLPadPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLH2PolyPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLH2PolyPainter(void *p);
   static void deleteArray_TGLH2PolyPainter(void *p);
   static void destruct_TGLH2PolyPainter(void *p);
   static void streamer_TGLH2PolyPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLLegoPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLLegoPainter(void *p);
   static void deleteArray_TGLLegoPainter(void *p);
   static void destruct_TGLLegoPainter(void *p);
   static void streamer_TGLLegoPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLLightSetSubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLLightSetSubEditor(void *p);
   static void deleteArray_TGLLightSetSubEditor(void *p);
   static void destruct_TGLLightSetSubEditor(void *p);

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

namespace ROOT {
   void TGLLightSetEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLLightSetEditor(void *p = 0);
   static void *newArray_TGLLightSetEditor(Long_t size, void *p);
   static void delete_TGLLightSetEditor(void *p);
   static void deleteArray_TGLLightSetEditor(void *p);
   static void destruct_TGLLightSetEditor(void *p);

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

namespace ROOT {
   void TGLOverlayButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLOverlayButton(void *p);
   static void deleteArray_TGLOverlayButton(void *p);
   static void destruct_TGLOverlayButton(void *p);

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

namespace ROOT {
   void TGLParametricEquationGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLParametricEquationGL(void *p = 0);
   static void *newArray_TGLParametricEquationGL(Long_t size, void *p);
   static void delete_TGLParametricEquationGL(void *p);
   static void deleteArray_TGLParametricEquationGL(void *p);
   static void destruct_TGLParametricEquationGL(void *p);
   static void streamer_TGLParametricEquationGL(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLParametricEquationGL*)
   {
      ::TGLParametricEquationGL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLParametricEquationGL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLParametricEquationGL", ::TGLParametricEquationGL::Class_Version(), "include/TGLParametricEquationGL.h", 23,
                  typeid(::TGLParametricEquationGL), DefineBehavior(ptr, ptr),
                  &::TGLParametricEquationGL::Dictionary, isa_proxy, 0,
                  sizeof(::TGLParametricEquationGL) );
      instance.SetNew(&new_TGLParametricEquationGL);
      instance.SetNewArray(&newArray_TGLParametricEquationGL);
      instance.SetDelete(&delete_TGLParametricEquationGL);
      instance.SetDeleteArray(&deleteArray_TGLParametricEquationGL);
      instance.SetDestructor(&destruct_TGLParametricEquationGL);
      instance.SetStreamerFunc(&streamer_TGLParametricEquationGL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLParametricEquationGL*)
   {
      return GenerateInitInstanceLocal((::TGLParametricEquationGL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLParametricEquationGL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLParametricPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLParametricPlot(void *p);
   static void deleteArray_TGLParametricPlot(void *p);
   static void destruct_TGLParametricPlot(void *p);
   static void streamer_TGLParametricPlot(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPolyLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPolyLine(void *p);
   static void deleteArray_TGLPolyLine(void *p);
   static void destruct_TGLPolyLine(void *p);
   static void streamer_TGLPolyLine(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPolyMarker_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLPolyMarker(void *p);
   static void deleteArray_TGLPolyMarker(void *p);
   static void destruct_TGLPolyMarker(void *p);
   static void streamer_TGLPolyMarker(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLPShapeObjEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLPShapeObjEditor(void *p = 0);
   static void *newArray_TGLPShapeObjEditor(Long_t size, void *p);
   static void delete_TGLPShapeObjEditor(void *p);
   static void deleteArray_TGLPShapeObjEditor(void *p);
   static void destruct_TGLPShapeObjEditor(void *p);

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

namespace ROOT {
   void TGLRotateManip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLRotateManip(void *p = 0);
   static void *newArray_TGLRotateManip(Long_t size, void *p);
   static void delete_TGLRotateManip(void *p);
   static void deleteArray_TGLRotateManip(void *p);
   static void destruct_TGLRotateManip(void *p);
   static void streamer_TGLRotateManip(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLRotateManip*)
   {
      ::TGLRotateManip *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGLRotateManip >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLRotateManip", ::TGLRotateManip::Class_Version(), "include/TGLRotateManip.h", 21,
                  typeid(::TGLRotateManip), DefineBehavior(ptr, ptr),
                  &::TGLRotateManip::Dictionary, isa_proxy, 0,
                  sizeof(::TGLRotateManip) );
      instance.SetNew(&new_TGLRotateManip);
      instance.SetNewArray(&newArray_TGLRotateManip);
      instance.SetDelete(&delete_TGLRotateManip);
      instance.SetDeleteArray(&deleteArray_TGLRotateManip);
      instance.SetDestructor(&destruct_TGLRotateManip);
      instance.SetStreamerFunc(&streamer_TGLRotateManip);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLRotateManip*)
   {
      return GenerateInitInstanceLocal((::TGLRotateManip*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLRotateManip*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGLSAViewer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLSAViewer(void *p);
   static void deleteArray_TGLSAViewer(void *p);
   static void destruct_TGLSAViewer(void *p);
   static void streamer_TGLSAViewer(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLSAFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLSAFrame(void *p);
   static void deleteArray_TGLSAFrame(void *p);
   static void destruct_TGLSAFrame(void *p);
   static void streamer_TGLSAFrame(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLScaleManip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLScaleManip(void *p = 0);
   static void *newArray_TGLScaleManip(Long_t size, void *p);
   static void delete_TGLScaleManip(void *p);
   static void deleteArray_TGLScaleManip(void *p);
   static void destruct_TGLScaleManip(void *p);
   static void streamer_TGLScaleManip(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLScenecLcLTSceneInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TGLScenecLcLTSceneInfo_Dictionary();
   static void *new_TGLScenecLcLTSceneInfo(void *p = 0);
   static void *newArray_TGLScenecLcLTSceneInfo(Long_t size, void *p);
   static void delete_TGLScenecLcLTSceneInfo(void *p);
   static void deleteArray_TGLScenecLcLTSceneInfo(void *p);
   static void destruct_TGLScenecLcLTSceneInfo(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGLScene::TSceneInfo*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TGLScene::TSceneInfo) == sizeof(::ROOT::Shadow::TGLScene::TSceneInfo));
      ::TGLScene::TSceneInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TGLScene::TSceneInfo),0);
      static ::ROOT::TGenericClassInfo 
         instance("TGLScene::TSceneInfo", "include/TGLScene.h", 81,
                  typeid(::TGLScene::TSceneInfo), DefineBehavior(ptr, ptr),
                  &TGLScenecLcLTSceneInfo_ShowMembers, &TGLScenecLcLTSceneInfo_Dictionary, isa_proxy, 4,
                  sizeof(::TGLScene::TSceneInfo) );
      instance.SetNew(&new_TGLScenecLcLTSceneInfo);
      instance.SetNewArray(&newArray_TGLScenecLcLTSceneInfo);
      instance.SetDelete(&delete_TGLScenecLcLTSceneInfo);
      instance.SetDeleteArray(&deleteArray_TGLScenecLcLTSceneInfo);
      instance.SetDestructor(&destruct_TGLScenecLcLTSceneInfo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGLScene::TSceneInfo*)
   {
      return GenerateInitInstanceLocal((::TGLScene::TSceneInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGLScene::TSceneInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TGLScenePad_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLScenePad(void *p);
   static void deleteArray_TGLScenePad(void *p);
   static void destruct_TGLScenePad(void *p);

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

namespace ROOT {
   void TGLSphere_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLSphere(void *p);
   static void deleteArray_TGLSphere(void *p);
   static void destruct_TGLSphere(void *p);
   static void streamer_TGLSphere(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLSurfacePainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLSurfacePainter(void *p);
   static void deleteArray_TGLSurfacePainter(void *p);
   static void destruct_TGLSurfacePainter(void *p);
   static void streamer_TGLSurfacePainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLTF3Painter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLTF3Painter(void *p);
   static void deleteArray_TGLTF3Painter(void *p);
   static void destruct_TGLTF3Painter(void *p);
   static void streamer_TGLTF3Painter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLIsoPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLIsoPainter(void *p);
   static void deleteArray_TGLIsoPainter(void *p);
   static void destruct_TGLIsoPainter(void *p);
   static void streamer_TGLIsoPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLTH3CompositionPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGLTH3CompositionPainter(void *p);
   static void deleteArray_TGLTH3CompositionPainter(void *p);
   static void destruct_TGLTH3CompositionPainter(void *p);
   static void streamer_TGLTH3CompositionPainter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGLTransManip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGLTransManip(void *p = 0);
   static void *newArray_TGLTransManip(Long_t size, void *p);
   static void delete_TGLTransManip(void *p);
   static void deleteArray_TGLTransManip(void *p);
   static void destruct_TGLTransManip(void *p);
   static void streamer_TGLTransManip(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TH2GL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2GL(void *p = 0);
   static void *newArray_TH2GL(Long_t size, void *p);
   static void delete_TH2GL(void *p);
   static void deleteArray_TH2GL(void *p);
   static void destruct_TH2GL(void *p);

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

namespace ROOT {
   void TH3GL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH3GL(void *p = 0);
   static void *newArray_TH3GL(Long_t size, void *p);
   static void delete_TH3GL(void *p);
   static void deleteArray_TH3GL(void *p);
   static void destruct_TH3GL(void *p);

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

namespace ROOT {
   void TPointSet3DGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPointSet3DGL(void *p = 0);
   static void *newArray_TPointSet3DGL(Long_t size, void *p);
   static void delete_TPointSet3DGL(void *p);
   static void deleteArray_TPointSet3DGL(void *p);
   static void destruct_TPointSet3DGL(void *p);

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

namespace ROOT {
   void TX11GLManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TX11GLManager(void *p = 0);
   static void *newArray_TX11GLManager(Long_t size, void *p);
   static void delete_TX11GLManager(void *p);
   static void deleteArray_TX11GLManager(void *p);
   static void destruct_TX11GLManager(void *p);
   static void streamer_TX11GLManager(TBuffer &buf, void *obj);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void TGLWidget::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLWidget.
      TClass *R__cl = ::TGLWidget::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLContext", &fGLContext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerData", (void*)&fInnerData);
      R__insp.InspectMember("pair<void*,void*>", (void*)&fInnerData, "fInnerData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWindowIndex", &fWindowIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGLFormat", &fGLFormat);
      R__insp.InspectMember(fGLFormat, "fGLFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFromInit", &fFromInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValidContexts", (void*)&fValidContexts);
      R__insp.InspectMember("set<TGLContext*>", (void*)&fValidContexts, "fValidContexts.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventHandler", &fEventHandler);
      TGFrame::ShowMembers(R__insp);
      TGLPaintDevice::ShowMembers(R__insp);
}

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

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

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

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

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

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

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

//______________________________________________________________________________
void TGLContextIdentity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLContextIdentity.
      TClass *R__cl = ::TGLContextIdentity::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontManager", &fFontManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCnt", &fCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClientCnt", &fClientCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLTrash", (void*)&fDLTrash);
      R__insp.InspectMember("TGLContextIdentity::DLTrash_t", (void*)&fDLTrash, "fDLTrash.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCtxs", (void*)&fCtxs);
      R__insp.InspectMember("TGLContextIdentity::CtxList_t", (void*)&fCtxs, "fCtxs.", false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLContextIdentity(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLContextIdentity : new ::TGLContextIdentity;
   }
   static void *newArray_TGLContextIdentity(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLContextIdentity[nElements] : new ::TGLContextIdentity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLContextIdentity(void *p) {
      delete ((::TGLContextIdentity*)p);
   }
   static void deleteArray_TGLContextIdentity(void *p) {
      delete [] ((::TGLContextIdentity*)p);
   }
   static void destruct_TGLContextIdentity(void *p) {
      typedef ::TGLContextIdentity current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLContextIdentity(TBuffer &buf, void *obj) {
      ((::TGLContextIdentity*)obj)->::TGLContextIdentity::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLContextIdentity

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLFormat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFormat : new ::TGLFormat;
   }
   static void *newArray_TGLFormat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFormat[nElements] : new ::TGLFormat[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLFormat(void *p) {
      delete ((::TGLFormat*)p);
   }
   static void deleteArray_TGLFormat(void *p) {
      delete [] ((::TGLFormat*)p);
   }
   static void destruct_TGLFormat(void *p) {
      typedef ::TGLFormat current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLFormat(TBuffer &buf, void *obj) {
      ((::TGLFormat*)obj)->::TGLFormat::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLFormat

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

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

//______________________________________________________________________________
void TGLFBO::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLFBO.
      TClass *R__cl = ::TGLFBO::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameBuffer", &fFrameBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorTexture", &fColorTexture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDepthBuffer", &fDepthBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMSFrameBuffer", &fMSFrameBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMSColorBuffer", &fMSColorBuffer);
      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(), "fMSSamples", &fMSSamples);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMSCoverageSamples", &fMSCoverageSamples);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWScale", &fWScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHScale", &fHScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRescaled", &fIsRescaled);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLFBO(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFBO : new ::TGLFBO;
   }
   static void *newArray_TGLFBO(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFBO[nElements] : new ::TGLFBO[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLFBO(void *p) {
      delete ((::TGLFBO*)p);
   }
   static void deleteArray_TGLFBO(void *p) {
      delete [] ((::TGLFBO*)p);
   }
   static void destruct_TGLFBO(void *p) {
      typedef ::TGLFBO current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLFBO

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLVertex3(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLVertex3 : new ::TGLVertex3;
   }
   static void *newArray_TGLVertex3(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLVertex3[nElements] : new ::TGLVertex3[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLVertex3(void *p) {
      delete ((::TGLVertex3*)p);
   }
   static void deleteArray_TGLVertex3(void *p) {
      delete [] ((::TGLVertex3*)p);
   }
   static void destruct_TGLVertex3(void *p) {
      typedef ::TGLVertex3 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLVertex3(TBuffer &buf, void *obj) {
      ((::TGLVertex3*)obj)->::TGLVertex3::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLVertex3

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

   TGLVertex3::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLVector3(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLVector3 : new ::TGLVector3;
   }
   static void *newArray_TGLVector3(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLVector3[nElements] : new ::TGLVector3[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLVector3(void *p) {
      delete ((::TGLVector3*)p);
   }
   static void deleteArray_TGLVector3(void *p) {
      delete [] ((::TGLVector3*)p);
   }
   static void destruct_TGLVector3(void *p) {
      typedef ::TGLVector3 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLVector3(TBuffer &buf, void *obj) {
      ((::TGLVector3*)obj)->::TGLVector3::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLVector3

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

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

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLRect(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLRect : new ::TGLRect;
   }
   static void *newArray_TGLRect(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLRect[nElements] : new ::TGLRect[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLRect(void *p) {
      delete ((::TGLRect*)p);
   }
   static void deleteArray_TGLRect(void *p) {
      delete [] ((::TGLRect*)p);
   }
   static void destruct_TGLRect(void *p) {
      typedef ::TGLRect current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLRect(TBuffer &buf, void *obj) {
      ((::TGLRect*)obj)->::TGLRect::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLRect

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPlane(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPlane : new ::TGLPlane;
   }
   static void *newArray_TGLPlane(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPlane[nElements] : new ::TGLPlane[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPlane(void *p) {
      delete ((::TGLPlane*)p);
   }
   static void deleteArray_TGLPlane(void *p) {
      delete [] ((::TGLPlane*)p);
   }
   static void destruct_TGLPlane(void *p) {
      typedef ::TGLPlane current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPlane(TBuffer &buf, void *obj) {
      ((::TGLPlane*)obj)->::TGLPlane::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPlane

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLMatrix(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLMatrix : new ::TGLMatrix;
   }
   static void *newArray_TGLMatrix(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLMatrix[nElements] : new ::TGLMatrix[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLMatrix(void *p) {
      delete ((::TGLMatrix*)p);
   }
   static void deleteArray_TGLMatrix(void *p) {
      delete [] ((::TGLMatrix*)p);
   }
   static void destruct_TGLMatrix(void *p) {
      typedef ::TGLMatrix current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLMatrix(TBuffer &buf, void *obj) {
      ((::TGLMatrix*)obj)->::TGLMatrix::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLMatrix

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLColor(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLColor : new ::TGLColor;
   }
   static void *newArray_TGLColor(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLColor[nElements] : new ::TGLColor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLColor(void *p) {
      delete ((::TGLColor*)p);
   }
   static void deleteArray_TGLColor(void *p) {
      delete [] ((::TGLColor*)p);
   }
   static void destruct_TGLColor(void *p) {
      typedef ::TGLColor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLColor(TBuffer &buf, void *obj) {
      ((::TGLColor*)obj)->::TGLColor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLColor

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

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

//______________________________________________________________________________
void TGLColorSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLColorSet.
      TClass *R__cl = ::TGLColorSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackground", &fBackground);
      R__insp.InspectMember(fBackground, "fBackground.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForeground", &fForeground);
      R__insp.InspectMember(fForeground, "fForeground.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutline", &fOutline);
      R__insp.InspectMember(fOutline, "fOutline.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkup", &fMarkup);
      R__insp.InspectMember(fMarkup, "fMarkup.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelection[5]", fSelection);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLColorSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLColorSet : new ::TGLColorSet;
   }
   static void *newArray_TGLColorSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLColorSet[nElements] : new ::TGLColorSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLColorSet(void *p) {
      delete ((::TGLColorSet*)p);
   }
   static void deleteArray_TGLColorSet(void *p) {
      delete [] ((::TGLColorSet*)p);
   }
   static void destruct_TGLColorSet(void *p) {
      typedef ::TGLColorSet current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLColorSet(TBuffer &buf, void *obj) {
      ((::TGLColorSet*)obj)->::TGLColorSet::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLColorSet

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

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

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLUtilcLcLTColorLocker(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLUtil::TColorLocker : new ::TGLUtil::TColorLocker;
   }
   static void *newArray_TGLUtilcLcLTColorLocker(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLUtil::TColorLocker[nElements] : new ::TGLUtil::TColorLocker[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLUtilcLcLTColorLocker(void *p) {
      delete ((::TGLUtil::TColorLocker*)p);
   }
   static void deleteArray_TGLUtilcLcLTColorLocker(void *p) {
      delete [] ((::TGLUtil::TColorLocker*)p);
   }
   static void destruct_TGLUtilcLcLTColorLocker(void *p) {
      typedef ::TGLUtil::TColorLocker current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLUtilcLcLTColorLocker(TBuffer &buf, void *obj) {
      ((::TGLUtil::TColorLocker*)obj)->::TGLUtil::TColorLocker::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLUtil::TColorLocker

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLUtilcLcLTDrawQualityModifier(void *p) {
      delete ((::TGLUtil::TDrawQualityModifier*)p);
   }
   static void deleteArray_TGLUtilcLcLTDrawQualityModifier(void *p) {
      delete [] ((::TGLUtil::TDrawQualityModifier*)p);
   }
   static void destruct_TGLUtilcLcLTDrawQualityModifier(void *p) {
      typedef ::TGLUtil::TDrawQualityModifier current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLUtilcLcLTDrawQualityModifier(TBuffer &buf, void *obj) {
      ((::TGLUtil::TDrawQualityModifier*)obj)->::TGLUtil::TDrawQualityModifier::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLUtil::TDrawQualityModifier

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

   ::Error("TGLUtil::TDrawQualityScaler::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLUtil::TDrawQualityScaler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLUtil::TDrawQualityScaler.
      TClass *R__cl = ::TGLUtil::TDrawQualityScaler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldQuality", &fOldQuality);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLUtilcLcLTDrawQualityScaler(void *p) {
      delete ((::TGLUtil::TDrawQualityScaler*)p);
   }
   static void deleteArray_TGLUtilcLcLTDrawQualityScaler(void *p) {
      delete [] ((::TGLUtil::TDrawQualityScaler*)p);
   }
   static void destruct_TGLUtilcLcLTDrawQualityScaler(void *p) {
      typedef ::TGLUtil::TDrawQualityScaler current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLUtilcLcLTDrawQualityScaler(TBuffer &buf, void *obj) {
      ((::TGLUtil::TDrawQualityScaler*)obj)->::TGLUtil::TDrawQualityScaler::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLUtil::TDrawQualityScaler

//______________________________________________________________________________
void TGLQuadric::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLQuadric.

   ::Error("TGLQuadric::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLQuadric::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLQuadric.
      TClass *R__cl = ::TGLQuadric::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQuad", &fQuad);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLQuadric(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLQuadric : new ::TGLQuadric;
   }
   static void *newArray_TGLQuadric(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLQuadric[nElements] : new ::TGLQuadric[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLQuadric(void *p) {
      delete ((::TGLQuadric*)p);
   }
   static void deleteArray_TGLQuadric(void *p) {
      delete [] ((::TGLQuadric*)p);
   }
   static void destruct_TGLQuadric(void *p) {
      typedef ::TGLQuadric current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLQuadric(TBuffer &buf, void *obj) {
      ((::TGLQuadric*)obj)->::TGLQuadric::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLQuadric

//______________________________________________________________________________
void TGLStopwatch::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLStopwatch.

   ::Error("TGLStopwatch::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLStopwatch::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLStopwatch.
      TClass *R__cl = ::TGLStopwatch::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnd", &fEnd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastRun", &fLastRun);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLStopwatch(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLStopwatch : new ::TGLStopwatch;
   }
   static void *newArray_TGLStopwatch(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLStopwatch[nElements] : new ::TGLStopwatch[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLStopwatch(void *p) {
      delete ((::TGLStopwatch*)p);
   }
   static void deleteArray_TGLStopwatch(void *p) {
      delete [] ((::TGLStopwatch*)p);
   }
   static void destruct_TGLStopwatch(void *p) {
      typedef ::TGLStopwatch current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLStopwatch(TBuffer &buf, void *obj) {
      ((::TGLStopwatch*)obj)->::TGLStopwatch::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLStopwatch

//______________________________________________________________________________
void TGLLockable::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLLockable.

   ::Error("TGLLockable::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLLockable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLLockable.
      TClass *R__cl = ::TGLLockable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLLockable(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLLockable : new ::TGLLockable;
   }
   static void *newArray_TGLLockable(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLLockable[nElements] : new ::TGLLockable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLLockable(void *p) {
      delete ((::TGLLockable*)p);
   }
   static void deleteArray_TGLLockable(void *p) {
      delete [] ((::TGLLockable*)p);
   }
   static void destruct_TGLLockable(void *p) {
      typedef ::TGLLockable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLLockable(TBuffer &buf, void *obj) {
      ((::TGLLockable*)obj)->::TGLLockable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLLockable

//______________________________________________________________________________
void TGLBoundingBox::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLBoundingBox.

   ::Error("TGLBoundingBox::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLBoundingBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLBoundingBox.
      TClass *R__cl = ::TGLBoundingBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVertex[8]", fVertex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDiagonal", &fDiagonal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxes[3]", fAxes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxesNorm[3]", fAxesNorm);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLBoundingBox(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLBoundingBox : new ::TGLBoundingBox;
   }
   static void *newArray_TGLBoundingBox(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLBoundingBox[nElements] : new ::TGLBoundingBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLBoundingBox(void *p) {
      delete ((::TGLBoundingBox*)p);
   }
   static void deleteArray_TGLBoundingBox(void *p) {
      delete [] ((::TGLBoundingBox*)p);
   }
   static void destruct_TGLBoundingBox(void *p) {
      typedef ::TGLBoundingBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLBoundingBox(TBuffer &buf, void *obj) {
      ((::TGLBoundingBox*)obj)->::TGLBoundingBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLBoundingBox

//______________________________________________________________________________
void TGLRnrCtx::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLRnrCtx.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLRnrCtx::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLRnrCtx::Class(),this);
   }
}

//______________________________________________________________________________
void TGLRnrCtx::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLRnrCtx.
      TClass *R__cl = ::TGLRnrCtx::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewer", &fViewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamera", &fCamera);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSceneInfo", &fSceneInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewerLOD", &fViewerLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSceneLOD", &fSceneLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCombiLOD", &fCombiLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShapeLOD", &fShapeLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShapePixSize", &fShapePixSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewerStyle", &fViewerStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSceneStyle", &fSceneStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewerWFLineW", &fViewerWFLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSceneWFLineW", &fSceneWFLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewerOLLineW", &fViewerOLLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSceneOLLineW", &fSceneOLLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewerClip", &fViewerClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSceneClip", &fSceneClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClip", &fClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawPass", &fDrawPass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStopwatch", &fStopwatch);
      R__insp.InspectMember(fStopwatch, "fStopwatch.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRenderTimeOut", &fRenderTimeOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRunning", &fIsRunning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasTimedOut", &fHasTimedOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlight", &fHighlight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlightOutline", &fHighlightOutline);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelection", &fSelection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSecSelection", &fSecSelection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPickRadius", &fPickRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPickRectangle", &fPickRectangle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectBuffer", &fSelectBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSetStack", &fColorSetStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRenderScale", &fRenderScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventKeySym", &fEventKeySym);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLCaptureOpen", &fDLCaptureOpen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLCtxIdentity", &fGLCtxIdentity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQuadric", &fQuadric);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrabImage", &fGrabImage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGrabBuffer", &fGrabBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGrabbedImage", &fGrabbedImage);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLRnrCtx(void *p) {
      delete ((::TGLRnrCtx*)p);
   }
   static void deleteArray_TGLRnrCtx(void *p) {
      delete [] ((::TGLRnrCtx*)p);
   }
   static void destruct_TGLRnrCtx(void *p) {
      typedef ::TGLRnrCtx current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLRnrCtx

//______________________________________________________________________________
void TGLSelectBuffer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSelectBuffer.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLSelectBuffer::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLSelectBuffer::Class(),this);
   }
}

//______________________________________________________________________________
void TGLSelectBuffer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSelectBuffer.
      TClass *R__cl = ::TGLSelectBuffer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufSize", &fBufSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuf", &fBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNRecords", &fNRecords);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSortedRecords", (void*)&fSortedRecords);
      R__insp.InspectMember("TGLSelectBuffer::vRawRecord_t", (void*)&fSortedRecords, "fSortedRecords.", false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLSelectBuffer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectBuffer : new ::TGLSelectBuffer;
   }
   static void *newArray_TGLSelectBuffer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectBuffer[nElements] : new ::TGLSelectBuffer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLSelectBuffer(void *p) {
      delete ((::TGLSelectBuffer*)p);
   }
   static void deleteArray_TGLSelectBuffer(void *p) {
      delete [] ((::TGLSelectBuffer*)p);
   }
   static void destruct_TGLSelectBuffer(void *p) {
      typedef ::TGLSelectBuffer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLSelectBuffer

//______________________________________________________________________________
void TGLSelectRecordBase::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSelectRecordBase.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLSelectRecordBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLSelectRecordBase::Class(),this);
   }
}

//______________________________________________________________________________
void TGLSelectRecordBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSelectRecordBase.
      TClass *R__cl = ::TGLSelectRecordBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fItems", &fItems);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinZ", &fMinZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxZ", &fMaxZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLSelectRecordBase(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectRecordBase : new ::TGLSelectRecordBase;
   }
   static void *newArray_TGLSelectRecordBase(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectRecordBase[nElements] : new ::TGLSelectRecordBase[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLSelectRecordBase(void *p) {
      delete ((::TGLSelectRecordBase*)p);
   }
   static void deleteArray_TGLSelectRecordBase(void *p) {
      delete [] ((::TGLSelectRecordBase*)p);
   }
   static void destruct_TGLSelectRecordBase(void *p) {
      typedef ::TGLSelectRecordBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLSelectRecordBase

//______________________________________________________________________________
void TGLSelectRecord::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSelectRecord.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLSelectRecord::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLSelectRecord::Class(),this);
   }
}

//______________________________________________________________________________
void TGLSelectRecord::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSelectRecord.
      TClass *R__cl = ::TGLSelectRecord::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransparent", &fTransparent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSceneInfo", &fSceneInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhysShape", &fPhysShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSpecific", &fSpecific);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMultiple", &fMultiple);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlight", &fHighlight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSecSelRes", &fSecSelRes);
      TGLSelectRecordBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLSelectRecord(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectRecord : new ::TGLSelectRecord;
   }
   static void *newArray_TGLSelectRecord(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectRecord[nElements] : new ::TGLSelectRecord[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLSelectRecord(void *p) {
      delete ((::TGLSelectRecord*)p);
   }
   static void deleteArray_TGLSelectRecord(void *p) {
      delete [] ((::TGLSelectRecord*)p);
   }
   static void destruct_TGLSelectRecord(void *p) {
      typedef ::TGLSelectRecord current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLSelectRecord

//______________________________________________________________________________
void TGLOvlSelectRecord::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLOvlSelectRecord.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLOvlSelectRecord::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLOvlSelectRecord::Class(),this);
   }
}

//______________________________________________________________________________
void TGLOvlSelectRecord::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLOvlSelectRecord.
      TClass *R__cl = ::TGLOvlSelectRecord::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOvlElement", &fOvlElement);
      TGLSelectRecordBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLOvlSelectRecord(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLOvlSelectRecord : new ::TGLOvlSelectRecord;
   }
   static void *newArray_TGLOvlSelectRecord(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLOvlSelectRecord[nElements] : new ::TGLOvlSelectRecord[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLOvlSelectRecord(void *p) {
      delete ((::TGLOvlSelectRecord*)p);
   }
   static void deleteArray_TGLOvlSelectRecord(void *p) {
      delete [] ((::TGLOvlSelectRecord*)p);
   }
   static void destruct_TGLOvlSelectRecord(void *p) {
      typedef ::TGLOvlSelectRecord current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLOvlSelectRecord

//______________________________________________________________________________
void TGLLogicalShape::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLLogicalShape.

   ::Error("TGLLogicalShape::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLLogicalShape::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLLogicalShape.
      TClass *R__cl = ::TGLLogicalShape::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRef", &fRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstPhysical", &fFirstPhysical);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExternalObj", &fExternalObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoundingBox", &fBoundingBox);
      R__insp.InspectMember(fBoundingBox, "fBoundingBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScene", &fScene);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLBase", &fDLBase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLSize", &fDLSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLValid", &fDLValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLCache", &fDLCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefStrong", &fRefStrong);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnExtObj", &fOwnExtObj);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLLogicalShape(void *p) {
      delete ((::TGLLogicalShape*)p);
   }
   static void deleteArray_TGLLogicalShape(void *p) {
      delete [] ((::TGLLogicalShape*)p);
   }
   static void destruct_TGLLogicalShape(void *p) {
      typedef ::TGLLogicalShape current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLLogicalShape(TBuffer &buf, void *obj) {
      ((::TGLLogicalShape*)obj)->::TGLLogicalShape::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLLogicalShape

//______________________________________________________________________________
void TGLPhysicalShape::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPhysicalShape.

   ::Error("TGLPhysicalShape::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLPhysicalShape::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPhysicalShape.
      TClass *R__cl = ::TGLPhysicalShape::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogicalShape", &fLogicalShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextPhysical", &fNextPhysical);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstPSRef", &fFirstPSRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransform", &fTransform);
      R__insp.InspectMember(fTransform, "fTransform.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoundingBox", &fBoundingBox);
      R__insp.InspectMember(fBoundingBox, "fBoundingBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor[17]", fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelected", &fSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInvertedWind", &fInvertedWind);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModified", &fModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fManip", &fManip);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPhysicalShape(void *p) {
      delete ((::TGLPhysicalShape*)p);
   }
   static void deleteArray_TGLPhysicalShape(void *p) {
      delete [] ((::TGLPhysicalShape*)p);
   }
   static void destruct_TGLPhysicalShape(void *p) {
      typedef ::TGLPhysicalShape current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPhysicalShape(TBuffer &buf, void *obj) {
      ((::TGLPhysicalShape*)obj)->::TGLPhysicalShape::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPhysicalShape

//______________________________________________________________________________
void TGLClip::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLClip.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLClip::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLClip::Class(),this);
   }
}

//______________________________________________________________________________
void TGLClip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLClip.
      TClass *R__cl = ::TGLClip::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeStamp", &fTimeStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
      TGLPhysicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLClip(void *p) {
      delete ((::TGLClip*)p);
   }
   static void deleteArray_TGLClip(void *p) {
      delete [] ((::TGLClip*)p);
   }
   static void destruct_TGLClip(void *p) {
      typedef ::TGLClip current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLClip

//______________________________________________________________________________
void TGLClipPlane::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLClipPlane.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLClipPlane::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLClipPlane::Class(),this);
   }
}

//______________________________________________________________________________
void TGLClipPlane::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLClipPlane.
      TClass *R__cl = ::TGLClipPlane::IsA();
      if (R__cl || R__insp.IsA()) { }
      TGLClip::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLClipPlane(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLClipPlane : new ::TGLClipPlane;
   }
   static void *newArray_TGLClipPlane(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLClipPlane[nElements] : new ::TGLClipPlane[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLClipPlane(void *p) {
      delete ((::TGLClipPlane*)p);
   }
   static void deleteArray_TGLClipPlane(void *p) {
      delete [] ((::TGLClipPlane*)p);
   }
   static void destruct_TGLClipPlane(void *p) {
      typedef ::TGLClipPlane current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLClipPlane

//______________________________________________________________________________
void TGLClipBox::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLClipBox.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLClipBox::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLClipBox::Class(),this);
   }
}

//______________________________________________________________________________
void TGLClipBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLClipBox.
      TClass *R__cl = ::TGLClipBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      TGLClip::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLClipBox(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLClipBox : new ::TGLClipBox;
   }
   static void *newArray_TGLClipBox(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLClipBox[nElements] : new ::TGLClipBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLClipBox(void *p) {
      delete ((::TGLClipBox*)p);
   }
   static void deleteArray_TGLClipBox(void *p) {
      delete [] ((::TGLClipBox*)p);
   }
   static void destruct_TGLClipBox(void *p) {
      typedef ::TGLClipBox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLClipBox

//______________________________________________________________________________
void TGLClipSet::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLClipSet.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLClipSet::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLClipSet::Class(),this);
   }
}

//______________________________________________________________________________
void TGLClipSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLClipSet.
      TClass *R__cl = ::TGLClipSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipPlane", &fClipPlane);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipBox", &fClipBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentClip", &fCurrentClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoUpdate", &fAutoUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowClip", &fShowClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowManip", &fShowManip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManip", &fManip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastBBox", &fLastBBox);
      R__insp.InspectMember(fLastBBox, "fLastBBox.");
      TGLOverlayElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLClipSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLClipSet : new ::TGLClipSet;
   }
   static void *newArray_TGLClipSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLClipSet[nElements] : new ::TGLClipSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLClipSet(void *p) {
      delete ((::TGLClipSet*)p);
   }
   static void deleteArray_TGLClipSet(void *p) {
      delete [] ((::TGLClipSet*)p);
   }
   static void destruct_TGLClipSet(void *p) {
      typedef ::TGLClipSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLClipSet

//______________________________________________________________________________
void TGLClipSetEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLClipSetEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLClipSetEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLClipSetEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TGLClipSetEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLClipSetEditor.
      TClass *R__cl = ::TGLClipSetEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSE", &fSE);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLClipSetEditor(void *p) {
      return  p ? new(p) ::TGLClipSetEditor : new ::TGLClipSetEditor;
   }
   static void *newArray_TGLClipSetEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGLClipSetEditor[nElements] : new ::TGLClipSetEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLClipSetEditor(void *p) {
      delete ((::TGLClipSetEditor*)p);
   }
   static void deleteArray_TGLClipSetEditor(void *p) {
      delete [] ((::TGLClipSetEditor*)p);
   }
   static void destruct_TGLClipSetEditor(void *p) {
      typedef ::TGLClipSetEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLClipSetEditor

//______________________________________________________________________________
void TGLClipSetSubEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLClipSetSubEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLClipSetSubEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLClipSetSubEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TGLClipSetSubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLClipSetSubEditor.
      TClass *R__cl = ::TGLClipSetSubEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentClip", &fCurrentClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeButtons", &fTypeButtons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlanePropFrame", &fPlanePropFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlaneProp[4]", &fPlaneProp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxPropFrame", &fBoxPropFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxProp[6]", &fBoxProp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipInside", &fClipInside);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoUpdate", &fAutoUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipEdit", &fClipEdit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipShow", &fClipShow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyButton", &fApplyButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResetButton", &fResetButton);
      TGVerticalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLClipSetSubEditor(void *p) {
      delete ((::TGLClipSetSubEditor*)p);
   }
   static void deleteArray_TGLClipSetSubEditor(void *p) {
      delete [] ((::TGLClipSetSubEditor*)p);
   }
   static void destruct_TGLClipSetSubEditor(void *p) {
      typedef ::TGLClipSetSubEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLClipSetSubEditor

//______________________________________________________________________________
void TGLManip::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLManip.

   TVirtualGLManip::Streamer(R__b);
}

//______________________________________________________________________________
void TGLManip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLManip.
      TClass *R__cl = ::TGLManip::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectedWidget", &fSelectedWidget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstMouse", (void*)&fFirstMouse);
      R__insp.InspectMember("TPoint", (void*)&fFirstMouse, "fFirstMouse.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastMouse", (void*)&fLastMouse);
      R__insp.InspectMember("TPoint", (void*)&fLastMouse, "fLastMouse.", true);
      TVirtualGLManip::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLManip(void *p) {
      delete ((::TGLManip*)p);
   }
   static void deleteArray_TGLManip(void *p) {
      delete [] ((::TGLManip*)p);
   }
   static void destruct_TGLManip(void *p) {
      typedef ::TGLManip current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLManip(TBuffer &buf, void *obj) {
      ((::TGLManip*)obj)->::TGLManip::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLManip

//______________________________________________________________________________
void TGLScaleManip::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLScaleManip.

   TGLManip::Streamer(R__b);
}

//______________________________________________________________________________
void TGLScaleManip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLScaleManip.
      TClass *R__cl = ::TGLScaleManip::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartScale", &fStartScale);
      R__insp.InspectMember(fStartScale, "fStartScale.");
      TGLManip::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLScaleManip(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLScaleManip : new ::TGLScaleManip;
   }
   static void *newArray_TGLScaleManip(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLScaleManip[nElements] : new ::TGLScaleManip[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLScaleManip(void *p) {
      delete ((::TGLScaleManip*)p);
   }
   static void deleteArray_TGLScaleManip(void *p) {
      delete [] ((::TGLScaleManip*)p);
   }
   static void destruct_TGLScaleManip(void *p) {
      typedef ::TGLScaleManip current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLScaleManip(TBuffer &buf, void *obj) {
      ((::TGLScaleManip*)obj)->::TGLScaleManip::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLScaleManip

//______________________________________________________________________________
void TGLTransManip::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLTransManip.

   TGLManip::Streamer(R__b);
}

//______________________________________________________________________________
void TGLTransManip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLTransManip.
      TClass *R__cl = ::TGLTransManip::IsA();
      if (R__cl || R__insp.IsA()) { }
      TGLManip::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLTransManip(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLTransManip : new ::TGLTransManip;
   }
   static void *newArray_TGLTransManip(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLTransManip[nElements] : new ::TGLTransManip[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLTransManip(void *p) {
      delete ((::TGLTransManip*)p);
   }
   static void deleteArray_TGLTransManip(void *p) {
      delete [] ((::TGLTransManip*)p);
   }
   static void destruct_TGLTransManip(void *p) {
      typedef ::TGLTransManip current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLTransManip(TBuffer &buf, void *obj) {
      ((::TGLTransManip*)obj)->::TGLTransManip::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLTransManip

//______________________________________________________________________________
void TGLRotateManip::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLRotateManip.

   TGLManip::Streamer(R__b);
}

//______________________________________________________________________________
void TGLRotateManip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLRotateManip.
      TClass *R__cl = ::TGLRotateManip::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShallowRing", &fShallowRing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShallowFront", &fShallowFront);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveRingPlane", &fActiveRingPlane);
      R__insp.InspectMember(fActiveRingPlane, "fActiveRingPlane.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveRingCenter", &fActiveRingCenter);
      R__insp.InspectMember(fActiveRingCenter, "fActiveRingCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRingLine", &fRingLine);
      R__insp.InspectMember(fRingLine, "fRingLine.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRingLineOld", &fRingLineOld);
      R__insp.InspectMember(fRingLineOld, "fRingLineOld.");
      TGLManip::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLRotateManip(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLRotateManip : new ::TGLRotateManip;
   }
   static void *newArray_TGLRotateManip(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLRotateManip[nElements] : new ::TGLRotateManip[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLRotateManip(void *p) {
      delete ((::TGLRotateManip*)p);
   }
   static void deleteArray_TGLRotateManip(void *p) {
      delete [] ((::TGLRotateManip*)p);
   }
   static void destruct_TGLRotateManip(void *p) {
      typedef ::TGLRotateManip current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLRotateManip(TBuffer &buf, void *obj) {
      ((::TGLRotateManip*)obj)->::TGLRotateManip::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLRotateManip

//______________________________________________________________________________
void TGLManipSet::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLManipSet.

   TGLOverlayElement::Streamer(R__b);
   TGLPShapeRef::Streamer(R__b);
}

//______________________________________________________________________________
void TGLManipSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLManipSet.
      TClass *R__cl = ::TGLManipSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManip[3]", &fManip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawBBox", &fDrawBBox);
      TGLOverlayElement::ShowMembers(R__insp);
      TGLPShapeRef::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLManipSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLManipSet : new ::TGLManipSet;
   }
   static void *newArray_TGLManipSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLManipSet[nElements] : new ::TGLManipSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLManipSet(void *p) {
      delete ((::TGLManipSet*)p);
   }
   static void deleteArray_TGLManipSet(void *p) {
      delete [] ((::TGLManipSet*)p);
   }
   static void destruct_TGLManipSet(void *p) {
      typedef ::TGLManipSet current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLManipSet(TBuffer &buf, void *obj) {
      ((::TGLManipSet*)obj)->::TGLManipSet::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLManipSet

//______________________________________________________________________________
void TGLCamera::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLCamera.

   ::Error("TGLCamera::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLCamera::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLCamera.
      TClass *R__cl = ::TGLCamera::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPreviousInterestBox", &fPreviousInterestBox);
      R__insp.InspectMember(fPreviousInterestBox, "fPreviousInterestBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterestFrustum", &fInterestFrustum);
      R__insp.InspectMember(fInterestFrustum, "fInterestFrustum.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterestFrustumAsBox", &fInterestFrustumAsBox);
      R__insp.InspectMember(fInterestFrustumAsBox, "fInterestFrustumAsBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCamBase", &fCamBase);
      R__insp.InspectMember(fCamBase, "fCamBase.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCamTrans", &fCamTrans);
      R__insp.InspectMember(fCamTrans, "fCamTrans.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExternalCenter", &fExternalCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixDefCenter", &fFixDefCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExtCenter", &fExtCenter);
      R__insp.InspectMember(fExtCenter, "fExtCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefCenter", &fDefCenter);
      R__insp.InspectMember(fDefCenter, "fDefCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFDCenter", &fFDCenter);
      R__insp.InspectMember(fFDCenter, "fFDCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenter", &fCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNearClip", &fNearClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFarClip", &fFarClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDollyDefault", &fDollyDefault);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDollyDistance", &fDollyDistance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVAxisMinAngle", &fVAxisMinAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheDirty", &fCacheDirty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeStamp", &fTimeStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastNoPickProjM", &fLastNoPickProjM);
      R__insp.InspectMember(fLastNoPickProjM, "fLastNoPickProjM.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProjM", &fProjM);
      R__insp.InspectMember(fProjM, "fProjM.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModVM", &fModVM);
      R__insp.InspectMember(fModVM, "fModVM.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipM", &fClipM);
      R__insp.InspectMember(fClipM, "fClipM.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrustumPlanes[6]", fFrustumPlanes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewport", &fViewport);
      R__insp.InspectMember(fViewport, "fViewport.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterestBox", &fInterestBox);
      R__insp.InspectMember(fInterestBox, "fInterestBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLargestSeen", &fLargestSeen);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLCamera(void *p) {
      delete ((::TGLCamera*)p);
   }
   static void deleteArray_TGLCamera(void *p) {
      delete [] ((::TGLCamera*)p);
   }
   static void destruct_TGLCamera(void *p) {
      typedef ::TGLCamera current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLCamera(TBuffer &buf, void *obj) {
      ((::TGLCamera*)obj)->::TGLCamera::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLCamera

//______________________________________________________________________________
void TGLOrthoCamera::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLOrthoCamera.

   TGLCamera::Streamer(R__b);
}

//______________________________________________________________________________
void TGLOrthoCamera::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLOrthoCamera.
      TClass *R__cl = ::TGLOrthoCamera::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnableRotate", &fEnableRotate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDollyToZoom", &fDollyToZoom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomMin", &fZoomMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomDefault", &fZoomDefault);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomMax", &fZoomMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolume", &fVolume);
      R__insp.InspectMember(fVolume, "fVolume.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefXSize", &fDefXSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefYSize", &fDefYSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoom", &fZoom);
      TGLCamera::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLOrthoCamera(void *p) {
      delete ((::TGLOrthoCamera*)p);
   }
   static void deleteArray_TGLOrthoCamera(void *p) {
      delete [] ((::TGLOrthoCamera*)p);
   }
   static void destruct_TGLOrthoCamera(void *p) {
      typedef ::TGLOrthoCamera current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLOrthoCamera(TBuffer &buf, void *obj) {
      ((::TGLOrthoCamera*)obj)->::TGLOrthoCamera::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLOrthoCamera

//______________________________________________________________________________
void TGLPerspectiveCamera::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPerspectiveCamera.

   TGLCamera::Streamer(R__b);
}

//______________________________________________________________________________
void TGLPerspectiveCamera::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPerspectiveCamera.
      TClass *R__cl = ::TGLPerspectiveCamera::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFOV", &fFOV);
      TGLCamera::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPerspectiveCamera(void *p) {
      delete ((::TGLPerspectiveCamera*)p);
   }
   static void deleteArray_TGLPerspectiveCamera(void *p) {
      delete [] ((::TGLPerspectiveCamera*)p);
   }
   static void destruct_TGLPerspectiveCamera(void *p) {
      typedef ::TGLPerspectiveCamera current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPerspectiveCamera(TBuffer &buf, void *obj) {
      ((::TGLPerspectiveCamera*)obj)->::TGLPerspectiveCamera::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPerspectiveCamera

//______________________________________________________________________________
void TGLCameraOverlay::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLCameraOverlay.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TGLOverlayElement::Streamer(R__b);
      R__b >> fShowOrthographic;
      R__b >> fShowPerspective;
      void *ptr_fOrthographicMode = (void*)&fOrthographicMode;
      R__b >> *reinterpret_cast<Int_t*>(ptr_fOrthographicMode);
      void *ptr_fPerspectiveMode = (void*)&fPerspectiveMode;
      R__b >> *reinterpret_cast<Int_t*>(ptr_fPerspectiveMode);
      R__b >> fAxisPainter;
      R__b >> fAxis;
      R__b >> fAxisExtend;
      R__b >> fUseAxisColors;
      fExternalRefPlane.Streamer(R__b);
      R__b >> fUseExternalRefPlane;
      R__b.ReadStaticArray((double*)fFrustum);
      R__b.CheckByteCount(R__s, R__c, TGLCameraOverlay::IsA());
   } else {
      R__c = R__b.WriteVersion(TGLCameraOverlay::IsA(), kTRUE);
      TGLOverlayElement::Streamer(R__b);
      R__b << fShowOrthographic;
      R__b << fShowPerspective;
      R__b << (Int_t)fOrthographicMode;
      R__b << (Int_t)fPerspectiveMode;
      R__b << fAxisPainter;
      R__b << fAxis;
      R__b << fAxisExtend;
      R__b << fUseAxisColors;
      fExternalRefPlane.Streamer(R__b);
      R__b << fUseExternalRefPlane;
      R__b.WriteArray(fFrustum, 4);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TGLCameraOverlay::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLCameraOverlay.
      TClass *R__cl = ::TGLCameraOverlay::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowOrthographic", &fShowOrthographic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowPerspective", &fShowPerspective);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthographicMode", &fOrthographicMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerspectiveMode", &fPerspectiveMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxisPainter", &fAxisPainter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxis", &fAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisExtend", &fAxisExtend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseAxisColors", &fUseAxisColors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExternalRefPlane", &fExternalRefPlane);
      R__insp.InspectMember(fExternalRefPlane, "fExternalRefPlane.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseExternalRefPlane", &fUseExternalRefPlane);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrustum[4]", fFrustum);
      TGLOverlayElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLCameraOverlay(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLCameraOverlay : new ::TGLCameraOverlay;
   }
   static void *newArray_TGLCameraOverlay(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLCameraOverlay[nElements] : new ::TGLCameraOverlay[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLCameraOverlay(void *p) {
      delete ((::TGLCameraOverlay*)p);
   }
   static void deleteArray_TGLCameraOverlay(void *p) {
      delete [] ((::TGLCameraOverlay*)p);
   }
   static void destruct_TGLCameraOverlay(void *p) {
      typedef ::TGLCameraOverlay current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLCameraOverlay(TBuffer &buf, void *obj) {
      ((::TGLCameraOverlay*)obj)->::TGLCameraOverlay::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLCameraOverlay

//______________________________________________________________________________
void TGLCameraGuide::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLCameraGuide.

   TGLOverlayElement::Streamer(R__b);
}

//______________________________________________________________________________
void TGLCameraGuide::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLCameraGuide.
      TClass *R__cl = ::TGLCameraGuide::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXPos", &fXPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYPos", &fYPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelAxis", &fSelAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInDrag", &fInDrag);
      TGLOverlayElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLCameraGuide(void *p) {
      delete ((::TGLCameraGuide*)p);
   }
   static void deleteArray_TGLCameraGuide(void *p) {
      delete [] ((::TGLCameraGuide*)p);
   }
   static void destruct_TGLCameraGuide(void *p) {
      typedef ::TGLCameraGuide current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLCameraGuide(TBuffer &buf, void *obj) {
      ((::TGLCameraGuide*)obj)->::TGLCameraGuide::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLCameraGuide

//______________________________________________________________________________
void TGLPlotCamera::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPlotCamera.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLPlotCamera::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLPlotCamera::Class(),this);
   }
}

//______________________________________________________________________________
void TGLPlotCamera::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPlotCamera.
      TClass *R__cl = ::TGLPlotCamera::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewport", &fViewport);
      R__insp.InspectMember(fViewport, "fViewport.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoom", &fZoom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShift", &fShift);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoBox[4]", fOrthoBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCenter", &fCenter);
      R__insp.InspectMember(fCenter, "fCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTruck", &fTruck);
      R__insp.InspectMember(fTruck, "fTruck.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArcBall", &fArcBall);
      R__insp.InspectMember(fArcBall, "fArcBall.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMousePos", (void*)&fMousePos);
      R__insp.InspectMember("TPoint", (void*)&fMousePos, "fMousePos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVpChanged", &fVpChanged);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPlotCamera(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPlotCamera : new ::TGLPlotCamera;
   }
   static void *newArray_TGLPlotCamera(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPlotCamera[nElements] : new ::TGLPlotCamera[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPlotCamera(void *p) {
      delete ((::TGLPlotCamera*)p);
   }
   static void deleteArray_TGLPlotCamera(void *p) {
      delete [] ((::TGLPlotCamera*)p);
   }
   static void destruct_TGLPlotCamera(void *p) {
      typedef ::TGLPlotCamera current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLPlotCamera

//______________________________________________________________________________
void TGLAutoRotator::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLAutoRotator.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLAutoRotator::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLAutoRotator::Class(),this);
   }
}

//______________________________________________________________________________
void TGLAutoRotator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLAutoRotator.
      TClass *R__cl = ::TGLAutoRotator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewer", &fViewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamera", &fCamera);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWatch", &fWatch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDt", &fDt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWPhi", &fWPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWTheta", &fWTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fATheta", &fATheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWDolly", &fWDolly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fADolly", &fADolly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetaA0", &fThetaA0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDollyA0", &fDollyA0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimerRunning", &fTimerRunning);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLAutoRotator(void *p) {
      delete ((::TGLAutoRotator*)p);
   }
   static void deleteArray_TGLAutoRotator(void *p) {
      delete [] ((::TGLAutoRotator*)p);
   }
   static void destruct_TGLAutoRotator(void *p) {
      typedef ::TGLAutoRotator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLAutoRotator

//______________________________________________________________________________
void TGLSceneBase::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSceneBase.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLSceneBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLSceneBase::Class(),this);
   }
}

//______________________________________________________________________________
void TGLSceneBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSceneBase.
      TClass *R__cl = ::TGLSceneBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSceneID", &fSceneID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
      R__insp.InspectMember(fTitle, "fTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeStamp", &fTimeStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinorStamp", &fMinorStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLOD", &fLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyle", &fStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWFLineW", &fWFLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOLLineW", &fOLLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClip", &fClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectable", &fSelectable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoundingBox", &fBoundingBox);
      R__insp.InspectMember(fBoundingBox, "fBoundingBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoundingBoxValid", &fBoundingBoxValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoFrustumCheck", &fDoFrustumCheck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoClipCheck", &fDoClipCheck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewers", (void*)&fViewers);
      R__insp.InspectMember("TGLSceneBase::ViewerList_t", (void*)&fViewers, "fViewers.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoDestruct", &fAutoDestruct);
      TGLLockable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLSceneBase(void *p) {
      delete ((::TGLSceneBase*)p);
   }
   static void deleteArray_TGLSceneBase(void *p) {
      delete [] ((::TGLSceneBase*)p);
   }
   static void destruct_TGLSceneBase(void *p) {
      typedef ::TGLSceneBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLSceneBase

//______________________________________________________________________________
void TGLScene::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLScene.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLScene::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLScene::Class(),this);
   }
}

//______________________________________________________________________________
void TGLScene::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLScene.
      TClass *R__cl = ::TGLScene::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogicalShapes", (void*)&fLogicalShapes);
      R__insp.InspectMember("TGLScene::LogicalShapeMap_t", (void*)&fLogicalShapes, "fLogicalShapes.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhysicalShapes", (void*)&fPhysicalShapes);
      R__insp.InspectMember("TGLScene::PhysicalShapeMap_t", (void*)&fPhysicalShapes, "fPhysicalShapes.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLCtxIdentity", &fGLCtxIdentity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInSmartRefresh", &fInSmartRefresh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmartRefreshCache", (void*)&fSmartRefreshCache);
      R__insp.InspectMember("TGLScene::LogicalShapeMap_t", (void*)&fSmartRefreshCache, "fSmartRefreshCache.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPointSizeScale", &fLastPointSizeScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastLineWidthScale", &fLastLineWidthScale);
      TGLSceneBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLScene(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLScene : new ::TGLScene;
   }
   static void *newArray_TGLScene(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLScene[nElements] : new ::TGLScene[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLScene(void *p) {
      delete ((::TGLScene*)p);
   }
   static void deleteArray_TGLScene(void *p) {
      delete [] ((::TGLScene*)p);
   }
   static void destruct_TGLScene(void *p) {
      typedef ::TGLScene current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLScene

//______________________________________________________________________________
void TGLScenePad::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLScenePad.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLScenePad::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLScenePad::Class(),this);
   }
}

//______________________________________________________________________________
void TGLScenePad::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLScenePad.
      TClass *R__cl = ::TGLScenePad::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInternalPIDs", &fInternalPIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNextInternalPID", &fNextInternalPID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPID", &fLastPID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAcceptedPhysicals", &fAcceptedPhysicals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComposite", &fComposite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCSLevel", &fCSLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCSTokens", (void*)&fCSTokens);
      R__insp.InspectMember("vector<CSPart_t>", (void*)&fCSTokens, "fCSTokens.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmartRefresh", &fSmartRefresh);
      TVirtualViewer3D::ShowMembers(R__insp);
      TGLScene::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLScenePad(void *p) {
      delete ((::TGLScenePad*)p);
   }
   static void deleteArray_TGLScenePad(void *p) {
      delete [] ((::TGLScenePad*)p);
   }
   static void destruct_TGLScenePad(void *p) {
      typedef ::TGLScenePad current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLScenePad

//______________________________________________________________________________
void TGLSceneInfo::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSceneInfo.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLSceneInfo::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLSceneInfo::Class(),this);
   }
}

//______________________________________________________________________________
void TGLSceneInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSceneInfo.
      TClass *R__cl = ::TGLSceneInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewer", &fViewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScene", &fScene);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLOD", &fLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyle", &fStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWFLineW", &fWFLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOLLineW", &fOLLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClip", &fClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastLOD", &fLastLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastStyle", &fLastStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastWFLineW", &fLastWFLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastOLLineW", &fLastOLLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastClip", &fLastClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastCamera", &fLastCamera);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSceneStamp", &fSceneStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipStamp", &fClipStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCameraStamp", &fCameraStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdateTimeouted", &fUpdateTimeouted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformedBBox", &fTransformedBBox);
      R__insp.InspectMember(fTransformedBBox, "fTransformedBBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewCheck", &fViewCheck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInFrustum", &fInFrustum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInClip", &fInClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipMode", &fClipMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrustumPlanes", (void*)&fFrustumPlanes);
      R__insp.InspectMember("TGLPlaneSet_t", (void*)&fFrustumPlanes, "fFrustumPlanes.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClipPlanes", (void*)&fClipPlanes);
      R__insp.InspectMember("TGLPlaneSet_t", (void*)&fClipPlanes, "fClipPlanes.", false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLSceneInfo(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSceneInfo : new ::TGLSceneInfo;
   }
   static void *newArray_TGLSceneInfo(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSceneInfo[nElements] : new ::TGLSceneInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLSceneInfo(void *p) {
      delete ((::TGLSceneInfo*)p);
   }
   static void deleteArray_TGLSceneInfo(void *p) {
      delete [] ((::TGLSceneInfo*)p);
   }
   static void destruct_TGLSceneInfo(void *p) {
      typedef ::TGLSceneInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLSceneInfo

//______________________________________________________________________________
namespace ROOT {
   void TGLScenecLcLTSceneInfo_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TGLScene::TSceneInfo.
      typedef ::ROOT::Shadow::TGLScene::TSceneInfo ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TGLScene::TSceneInfo*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShapesOfInterest", (void*)&sobj->fShapesOfInterest);
      R__insp.InspectMember("TGLScene::ShapeVec_t", (void*)&sobj->fShapesOfInterest, "fShapesOfInterest.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisibleElements", (void*)&sobj->fVisibleElements);
      R__insp.InspectMember("TGLScene::DrawElementVec_t", (void*)&sobj->fVisibleElements, "fVisibleElements.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinorStamp", &sobj->fMinorStamp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOpaqueElements", (void*)&sobj->fOpaqueElements);
      R__insp.InspectMember("TGLScene::DrawElementPtrVec_t", (void*)&sobj->fOpaqueElements, "fOpaqueElements.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTranspElements", (void*)&sobj->fTranspElements);
      R__insp.InspectMember("TGLScene::DrawElementPtrVec_t", (void*)&sobj->fTranspElements, "fTranspElements.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelOpaqueElements", (void*)&sobj->fSelOpaqueElements);
      R__insp.InspectMember("TGLScene::DrawElementPtrVec_t", (void*)&sobj->fSelOpaqueElements, "fSelOpaqueElements.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelTranspElements", (void*)&sobj->fSelTranspElements);
      R__insp.InspectMember("TGLScene::DrawElementPtrVec_t", (void*)&sobj->fSelTranspElements, "fSelTranspElements.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOpaqueCnt", &sobj->fOpaqueCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTranspCnt", &sobj->fTranspCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsPixelCnt", &sobj->fAsPixelCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fByShapeCnt", (void*)&sobj->fByShapeCnt);
      R__insp.InspectMember("map<TClass*,UInt_t>", (void*)&sobj->fByShapeCnt, "fByShapeCnt.", false);
      sobj->TGLSceneInfo::ShowMembers(R__insp);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLScenecLcLTSceneInfo(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLScene::TSceneInfo : new ::TGLScene::TSceneInfo;
   }
   static void *newArray_TGLScenecLcLTSceneInfo(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLScene::TSceneInfo[nElements] : new ::TGLScene::TSceneInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLScenecLcLTSceneInfo(void *p) {
      delete ((::TGLScene::TSceneInfo*)p);
   }
   static void deleteArray_TGLScenecLcLTSceneInfo(void *p) {
      delete [] ((::TGLScene::TSceneInfo*)p);
   }
   static void destruct_TGLScenecLcLTSceneInfo(void *p) {
      typedef ::TGLScene::TSceneInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLScene::TSceneInfo

//______________________________________________________________________________
void TGLOverlayElement::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLOverlayElement.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLOverlayElement::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLOverlayElement::Class(),this);
   }
}

//______________________________________________________________________________
void TGLOverlayElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLOverlayElement.
      TClass *R__cl = ::TGLOverlayElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRole", &fRole);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLOverlayElement(void *p) {
      delete ((::TGLOverlayElement*)p);
   }
   static void deleteArray_TGLOverlayElement(void *p) {
      delete [] ((::TGLOverlayElement*)p);
   }
   static void destruct_TGLOverlayElement(void *p) {
      typedef ::TGLOverlayElement current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLOverlayElement

//______________________________________________________________________________
void TGLOverlayList::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLOverlayList.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLOverlayList::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLOverlayList::Class(),this);
   }
}

//______________________________________________________________________________
void TGLOverlayList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLOverlayList.
      TClass *R__cl = ::TGLOverlayList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElements", (void*)&fElements);
      R__insp.InspectMember("list<TGLOverlayElement*>", (void*)&fElements, "fElements.", false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLOverlayList(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLOverlayList : new ::TGLOverlayList;
   }
   static void *newArray_TGLOverlayList(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLOverlayList[nElements] : new ::TGLOverlayList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLOverlayList(void *p) {
      delete ((::TGLOverlayList*)p);
   }
   static void deleteArray_TGLOverlayList(void *p) {
      delete [] ((::TGLOverlayList*)p);
   }
   static void destruct_TGLOverlayList(void *p) {
      typedef ::TGLOverlayList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLOverlayList

//______________________________________________________________________________
void TGLOverlayButton::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLOverlayButton.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLOverlayButton::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLOverlayButton::Class(),this);
   }
}

//______________________________________________________________________________
void TGLOverlayButton::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLOverlayButton.
      TClass *R__cl = ::TGLOverlayButton::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fText", &fText);
      R__insp.InspectMember(fText, "fText.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveID", &fActiveID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackColor", &fBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextColor", &fTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormAlpha", &fNormAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighAlpha", &fHighAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPosX", &fPosX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPosY", &fPosY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidth", &fWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFont", &fFont);
      R__insp.InspectMember(fFont, "fFont.");
      TGLOverlayElement::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLOverlayButton(void *p) {
      delete ((::TGLOverlayButton*)p);
   }
   static void deleteArray_TGLOverlayButton(void *p) {
      delete [] ((::TGLOverlayButton*)p);
   }
   static void destruct_TGLOverlayButton(void *p) {
      typedef ::TGLOverlayButton current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLOverlayButton

//______________________________________________________________________________
void TGLAnnotation::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLAnnotation.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLAnnotation::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLAnnotation::Class(),this);
   }
}

//______________________________________________________________________________
void TGLAnnotation::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLAnnotation.
      TClass *R__cl = ::TGLAnnotation::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPosX", &fPosX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPosY", &fPosY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidth", &fWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseX", &fMouseX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseY", &fMouseY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrag", &fDrag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawW", &fDrawW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawH", &fDrawH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeDrag", &fTextSizeDrag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointer", &fPointer);
      R__insp.InspectMember(fPointer, "fPointer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainFrame", &fMainFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextEdit", &fTextEdit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fText", &fText);
      R__insp.InspectMember(fText, "fText.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSize", &fTextSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFont", &fFont);
      R__insp.InspectMember(fFont, "fFont.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMenuFont", &fMenuFont);
      R__insp.InspectMember(fMenuFont, "fMenuFont.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextAlign", &fTextAlign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackColor", &fBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextColor", &fTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransparency", &fTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawRefLine", &fDrawRefLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseColorSet", &fUseColorSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllowClose", &fAllowClose);
      TGLOverlayElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLAnnotation(void *p) {
      delete ((::TGLAnnotation*)p);
   }
   static void deleteArray_TGLAnnotation(void *p) {
      delete [] ((::TGLAnnotation*)p);
   }
   static void destruct_TGLAnnotation(void *p) {
      typedef ::TGLAnnotation current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLAnnotation

//______________________________________________________________________________
void TGLViewerBase::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLViewerBase.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLViewerBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLViewerBase::Class(),this);
   }
}

//______________________________________________________________________________
void TGLViewerBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLViewerBase.
      TClass *R__cl = ::TGLViewerBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrCtx", &fRnrCtx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamera", &fCamera);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClip", &fClip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLOD", &fLOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyle", &fStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWFLineW", &fWFLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOLLineW", &fOLLineW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResetSceneInfosOnRender", &fResetSceneInfosOnRender);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanged", &fChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScenes", (void*)&fScenes);
      R__insp.InspectMember("TGLViewerBase::SceneInfoList_t", (void*)&fScenes, "fScenes.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisScenes", (void*)&fVisScenes);
      R__insp.InspectMember("TGLViewerBase::SceneInfoVec_t", (void*)&fVisScenes, "fVisScenes.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverallBoundingBox", &fOverallBoundingBox);
      R__insp.InspectMember(fOverallBoundingBox, "fOverallBoundingBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverlay", (void*)&fOverlay);
      R__insp.InspectMember("TGLViewerBase::OverlayElmVec_t", (void*)&fOverlay, "fOverlay.", false);
      TGLLockable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLViewerBase(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLViewerBase : new ::TGLViewerBase;
   }
   static void *newArray_TGLViewerBase(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLViewerBase[nElements] : new ::TGLViewerBase[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLViewerBase(void *p) {
      delete ((::TGLViewerBase*)p);
   }
   static void deleteArray_TGLViewerBase(void *p) {
      delete [] ((::TGLViewerBase*)p);
   }
   static void destruct_TGLViewerBase(void *p) {
      typedef ::TGLViewerBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLViewerBase

//______________________________________________________________________________
void TGLViewer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLViewer.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLViewer::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLViewer::Class(),this);
   }
}

//______________________________________________________________________________
void TGLViewer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLViewer.
      TClass *R__cl = ::TGLViewer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContextMenu", &fContextMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerspectiveCameraXOZ", &fPerspectiveCameraXOZ);
      R__insp.InspectMember(fPerspectiveCameraXOZ, "fPerspectiveCameraXOZ.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerspectiveCameraYOZ", &fPerspectiveCameraYOZ);
      R__insp.InspectMember(fPerspectiveCameraYOZ, "fPerspectiveCameraYOZ.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerspectiveCameraXOY", &fPerspectiveCameraXOY);
      R__insp.InspectMember(fPerspectiveCameraXOY, "fPerspectiveCameraXOY.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoXOYCamera", &fOrthoXOYCamera);
      R__insp.InspectMember(fOrthoXOYCamera, "fOrthoXOYCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoXOZCamera", &fOrthoXOZCamera);
      R__insp.InspectMember(fOrthoXOZCamera, "fOrthoXOZCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoZOYCamera", &fOrthoZOYCamera);
      R__insp.InspectMember(fOrthoZOYCamera, "fOrthoZOYCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoXnOYCamera", &fOrthoXnOYCamera);
      R__insp.InspectMember(fOrthoXnOYCamera, "fOrthoXnOYCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoXnOZCamera", &fOrthoXnOZCamera);
      R__insp.InspectMember(fOrthoXnOZCamera, "fOrthoXnOZCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthoZnOYCamera", &fOrthoZnOYCamera);
      R__insp.InspectMember(fOrthoZnOYCamera, "fOrthoZnOYCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentCamera", &fCurrentCamera);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoRotator", &fAutoRotator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStereo", &fStereo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStereoZeroParallax", &fStereoZeroParallax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStereoEyeOffsetFac", &fStereoEyeOffsetFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStereoFrustumAsymFac", &fStereoFrustumAsymFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLightSet", &fLightSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipSet", &fClipSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentSelRec", &fCurrentSelRec);
      R__insp.InspectMember(fCurrentSelRec, "fCurrentSelRec.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelRec", &fSelRec);
      R__insp.InspectMember(fSelRec, "fSelRec.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSecSelRec", &fSecSelRec);
      R__insp.InspectMember(fSecSelRec, "fSecSelRec.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedPShapeRef", &fSelectedPShapeRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentOvlElm", &fCurrentOvlElm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOvlSelRec", &fOvlSelRec);
      R__insp.InspectMember(fOvlSelRec, "fOvlSelRec.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventHandler", &fEventHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPShapeWrap", &fPShapeWrap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPushAction", &fPushAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDragAction", &fDragAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRedrawTimer", &fRedrawTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSceneDrawTimeHQ", &fMaxSceneDrawTimeHQ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSceneDrawTimeLQ", &fMaxSceneDrawTimeLQ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewport", &fViewport);
      R__insp.InspectMember(fViewport, "fViewport.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDarkColorSet", &fDarkColorSet);
      R__insp.InspectMember(fDarkColorSet, "fDarkColorSet.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightColorSet", &fLightColorSet);
      R__insp.InspectMember(fLightColorSet, "fLightColorSet.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointScale", &fPointScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineScale", &fLineScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmoothPoints", &fSmoothPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmoothLines", &fSmoothLines);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxesType", &fAxesType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxesDepthTest", &fAxesDepthTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReferenceOn", &fReferenceOn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReferencePos", &fReferencePos);
      R__insp.InspectMember(fReferencePos, "fReferencePos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawCameraCenter", &fDrawCameraCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraOverlay", &fCameraOverlay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSmartRefresh", &fSmartRefresh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebugMode", &fDebugMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsPrinting", &fIsPrinting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPictureFileName", &fPictureFileName);
      R__insp.InspectMember(fPictureFileName, "fPictureFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFader", &fFader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLWidget", &fGLWidget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGLDevice", &fGLDevice);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLCtxId", &fGLCtxId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIgnoreSizesOnUpdate", &fIgnoreSizesOnUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResetCamerasOnUpdate", &fResetCamerasOnUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResetCamerasOnNextUpdate", &fResetCamerasOnNextUpdate);
      TVirtualViewer3D::ShowMembers(R__insp);
      TGLViewerBase::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLViewer(void *p) {
      delete ((::TGLViewer*)p);
   }
   static void deleteArray_TGLViewer(void *p) {
      delete [] ((::TGLViewer*)p);
   }
   static void destruct_TGLViewer(void *p) {
      typedef ::TGLViewer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLViewer

//______________________________________________________________________________
void TGLEventHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLEventHandler.

   TGEventHandler::Streamer(R__b);
}

//______________________________________________________________________________
void TGLEventHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLEventHandler.
      TClass *R__cl = ::TGLEventHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLViewer", &fGLViewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMouseTimer", &fMouseTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fButtonPushPos", (void*)&fButtonPushPos);
      R__insp.InspectMember("TPoint", (void*)&fButtonPushPos, "fButtonPushPos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPos", (void*)&fLastPos);
      R__insp.InspectMember("TPoint", (void*)&fLastPos, "fLastPos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastMouseOverPos", (void*)&fLastMouseOverPos);
      R__insp.InspectMember("TPoint", (void*)&fLastMouseOverPos, "fLastMouseOverPos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastMouseOverShape", &fLastMouseOverShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTooltip", &fTooltip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastGlobalPos", (void*)&fLastGlobalPos);
      R__insp.InspectMember("TPoint", (void*)&fLastGlobalPos, "fLastGlobalPos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTooltipPos", (void*)&fTooltipPos);
      R__insp.InspectMember("TPoint", (void*)&fTooltipPos, "fTooltipPos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveButtonID", &fActiveButtonID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastEventState", &fLastEventState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIgnoreButtonUp", &fIgnoreButtonUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInPointerGrab", &fInPointerGrab);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseTimerRunning", &fMouseTimerRunning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTooltipShown", &fTooltipShown);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTooltipPixelTolerance", &fTooltipPixelTolerance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSecSelType", &fSecSelType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoInternalSelection", &fDoInternalSelection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewerCentricControls", &fViewerCentricControls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArrowKeyFactor", &fArrowKeyFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseDragFactor", &fMouseDragFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseWheelFactor", &fMouseWheelFactor);
      TGEventHandler::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLEventHandler(void *p) {
      delete ((::TGLEventHandler*)p);
   }
   static void deleteArray_TGLEventHandler(void *p) {
      delete [] ((::TGLEventHandler*)p);
   }
   static void destruct_TGLEventHandler(void *p) {
      typedef ::TGLEventHandler current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLEventHandler(TBuffer &buf, void *obj) {
      ((::TGLEventHandler*)obj)->::TGLEventHandler::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLEventHandler

//______________________________________________________________________________
void TGLFaderHelper::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLFaderHelper.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLFaderHelper::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLFaderHelper::Class(),this);
   }
}

//______________________________________________________________________________
void TGLFaderHelper::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLFaderHelper.
      TClass *R__cl = ::TGLFaderHelper::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewer", &fViewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFadeTarget", &fFadeTarget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &fTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSteps", &fNSteps);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLFaderHelper(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFaderHelper : new ::TGLFaderHelper;
   }
   static void *newArray_TGLFaderHelper(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFaderHelper[nElements] : new ::TGLFaderHelper[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLFaderHelper(void *p) {
      delete ((::TGLFaderHelper*)p);
   }
   static void deleteArray_TGLFaderHelper(void *p) {
      delete [] ((::TGLFaderHelper*)p);
   }
   static void destruct_TGLFaderHelper(void *p) {
      typedef ::TGLFaderHelper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLFaderHelper

//______________________________________________________________________________
void TGLViewerEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLViewerEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLViewerEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLViewerEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TGLViewerEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLViewerEditor.
      TClass *R__cl = ::TGLViewerEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGuidesFrame", &fGuidesFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipFrame", &fClipFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStereoFrame", &fStereoFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLightSet", &fLightSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClearColor", &fClearColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIgnoreSizesOnUpdate", &fIgnoreSizesOnUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResetCamerasOnUpdate", &fResetCamerasOnUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpdateScene", &fUpdateScene);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraHome", &fCameraHome);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxSceneDrawTimeHQ", &fMaxSceneDrawTimeHQ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxSceneDrawTimeLQ", &fMaxSceneDrawTimeLQ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointSizeScale", &fPointSizeScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineWidthScale", &fLineWidthScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointSmooth", &fPointSmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineSmooth", &fLineSmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWFLineWidth", &fWFLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOLLineWidth", &fOLLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraCenterExt", &fCameraCenterExt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCaptureCenter", &fCaptureCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawCameraCenter", &fDrawCameraCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraCenterX", &fCameraCenterX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraCenterY", &fCameraCenterY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraCenterZ", &fCameraCenterZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCaptureAnnotate", &fCaptureAnnotate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxesType", &fAxesType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxesContainer", &fAxesContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxesNone", &fAxesNone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxesEdge", &fAxesEdge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxesOrigin", &fAxesOrigin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxesDepthTest", &fAxesDepthTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefContainer", &fRefContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReferenceOn", &fReferenceOn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReferencePosX", &fReferencePosX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReferencePosY", &fReferencePosY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReferencePosZ", &fReferencePosZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamContainer", &fCamContainer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamMode", &fCamMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamOverlayOn", &fCamOverlayOn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClipSet", &fClipSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fARotDt", &fARotDt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fARotWPhi", &fARotWPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fARotATheta", &fARotATheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fARotWTheta", &fARotWTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fARotADolly", &fARotADolly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fARotWDolly", &fARotWDolly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStereoZeroParallax", &fStereoZeroParallax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStereoEyeOffsetFac", &fStereoEyeOffsetFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStereoFrustumAsymFac", &fStereoFrustumAsymFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewer", &fViewer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsInPad", &fIsInPad);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLViewerEditor(void *p) {
      return  p ? new(p) ::TGLViewerEditor : new ::TGLViewerEditor;
   }
   static void *newArray_TGLViewerEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGLViewerEditor[nElements] : new ::TGLViewerEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLViewerEditor(void *p) {
      delete ((::TGLViewerEditor*)p);
   }
   static void deleteArray_TGLViewerEditor(void *p) {
      delete [] ((::TGLViewerEditor*)p);
   }
   static void destruct_TGLViewerEditor(void *p) {
      typedef ::TGLViewerEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLViewerEditor

//______________________________________________________________________________
void TGLEmbeddedViewer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLEmbeddedViewer.

   TGLViewer::Streamer(R__b);
}

//______________________________________________________________________________
void TGLEmbeddedViewer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLEmbeddedViewer.
      TClass *R__cl = ::TGLEmbeddedViewer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBorder", &fBorder);
      TGLViewer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLEmbeddedViewer(void *p) {
      delete ((::TGLEmbeddedViewer*)p);
   }
   static void deleteArray_TGLEmbeddedViewer(void *p) {
      delete [] ((::TGLEmbeddedViewer*)p);
   }
   static void destruct_TGLEmbeddedViewer(void *p) {
      typedef ::TGLEmbeddedViewer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLEmbeddedViewer(TBuffer &buf, void *obj) {
      ((::TGLEmbeddedViewer*)obj)->::TGLEmbeddedViewer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLEmbeddedViewer

//______________________________________________________________________________
void TGLSAViewer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSAViewer.

   TGLViewer::Streamer(R__b);
}

//______________________________________________________________________________
void TGLSAViewer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSAViewer.
      TClass *R__cl = ::TGLSAViewer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFormat", &fFormat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileMenu", &fFileMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileSaveMenu", &fFileSaveMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCameraMenu", &fCameraMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHelpMenu", &fHelpMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeftVerticalFrame", &fLeftVerticalFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRightVerticalFrame", &fRightVerticalFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirName", &fDirName);
      R__insp.InspectMember(fDirName, "fDirName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeIdx", &fTypeIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverwrite", &fOverwrite);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBut", &fMenuBut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHideMenuBar", &fHideMenuBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHidingTimer", &fMenuHidingTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMenuHidingShowMenu", &fMenuHidingShowMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeleteMenuBar", &fDeleteMenuBar);
      TGLViewer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLSAViewer(void *p) {
      delete ((::TGLSAViewer*)p);
   }
   static void deleteArray_TGLSAViewer(void *p) {
      delete [] ((::TGLSAViewer*)p);
   }
   static void destruct_TGLSAViewer(void *p) {
      typedef ::TGLSAViewer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLSAViewer(TBuffer &buf, void *obj) {
      ((::TGLSAViewer*)obj)->::TGLSAViewer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLSAViewer

//______________________________________________________________________________
void TGLSAFrame::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSAFrame.

   TGMainFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGLSAFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSAFrame.
      TClass *R__cl = ::TGLSAFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      TGMainFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLSAFrame(void *p) {
      delete ((::TGLSAFrame*)p);
   }
   static void deleteArray_TGLSAFrame(void *p) {
      delete [] ((::TGLSAFrame*)p);
   }
   static void destruct_TGLSAFrame(void *p) {
      typedef ::TGLSAFrame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLSAFrame(TBuffer &buf, void *obj) {
      ((::TGLSAFrame*)obj)->::TGLSAFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLSAFrame

//______________________________________________________________________________
void TGLPShapeRef::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPShapeRef.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLPShapeRef::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLPShapeRef::Class(),this);
   }
}

//______________________________________________________________________________
void TGLPShapeRef::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPShapeRef.
      TClass *R__cl = ::TGLPShapeRef::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextPSRef", &fNextPSRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPShape", &fPShape);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPShapeRef(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPShapeRef : new ::TGLPShapeRef;
   }
   static void *newArray_TGLPShapeRef(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPShapeRef[nElements] : new ::TGLPShapeRef[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPShapeRef(void *p) {
      delete ((::TGLPShapeRef*)p);
   }
   static void deleteArray_TGLPShapeRef(void *p) {
      delete [] ((::TGLPShapeRef*)p);
   }
   static void destruct_TGLPShapeRef(void *p) {
      typedef ::TGLPShapeRef current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLPShapeRef

//______________________________________________________________________________
void TGLPShapeObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPShapeObj.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLPShapeObj::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLPShapeObj::Class(),this);
   }
}

//______________________________________________________________________________
void TGLPShapeObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPShapeObj.
      TClass *R__cl = ::TGLPShapeObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPShape", &fPShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewer", &fViewer);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPShapeObj(void *p) {
      return  p ? new(p) ::TGLPShapeObj : new ::TGLPShapeObj;
   }
   static void *newArray_TGLPShapeObj(Long_t nElements, void *p) {
      return p ? new(p) ::TGLPShapeObj[nElements] : new ::TGLPShapeObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPShapeObj(void *p) {
      delete ((::TGLPShapeObj*)p);
   }
   static void deleteArray_TGLPShapeObj(void *p) {
      delete [] ((::TGLPShapeObj*)p);
   }
   static void destruct_TGLPShapeObj(void *p) {
      typedef ::TGLPShapeObj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLPShapeObj

//______________________________________________________________________________
void TGLPShapeObjEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPShapeObjEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLPShapeObjEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLPShapeObjEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TGLPShapeObjEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPShapeObjEditor.
      TClass *R__cl = ::TGLPShapeObjEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLMode", &fLMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLb", &fLb);
      R__insp.InspectMember(fLb, "fLb.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLe", &fLe);
      R__insp.InspectMember(fLe, "fLe.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLl", &fLl);
      R__insp.InspectMember(fLl, "fLl.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLs", &fLs);
      R__insp.InspectMember(fLs, "fLs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeoFrame", &fGeoFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeomData[6]", &fGeomData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeoApplyButton", &fGeoApplyButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorFrame", &fColorFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatView", &fMatView);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLightTypes[4]", &fLightTypes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRedSlider", &fRedSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGreenSlider", &fGreenSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBlueSlider", &fBlueSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlphaSlider", &fAlphaSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShineSlider", &fShineSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorApplyButton", &fColorApplyButton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorApplyFamily", &fColorApplyFamily);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRGBA[17]", fRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGLWin", &fGLWin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCtx", &fCtx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPShapeObj", &fPShapeObj);
      TGedFrame::ShowMembers(R__insp);
      TGLPShapeRef::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPShapeObjEditor(void *p) {
      return  p ? new(p) ::TGLPShapeObjEditor : new ::TGLPShapeObjEditor;
   }
   static void *newArray_TGLPShapeObjEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGLPShapeObjEditor[nElements] : new ::TGLPShapeObjEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPShapeObjEditor(void *p) {
      delete ((::TGLPShapeObjEditor*)p);
   }
   static void deleteArray_TGLPShapeObjEditor(void *p) {
      delete [] ((::TGLPShapeObjEditor*)p);
   }
   static void destruct_TGLPShapeObjEditor(void *p) {
      typedef ::TGLPShapeObjEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLPShapeObjEditor

//______________________________________________________________________________
void TGLLightSet::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLLightSet.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLLightSet::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLLightSet::Class(),this);
   }
}

//______________________________________________________________________________
void TGLLightSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLLightSet.
      TClass *R__cl = ::TGLLightSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightState", &fLightState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSpecular", &fUseSpecular);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrontPower", &fFrontPower);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSidePower", &fSidePower);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSpecularPower", &fSpecularPower);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLLightSet(void *p) {
      return  p ? new(p) ::TGLLightSet : new ::TGLLightSet;
   }
   static void *newArray_TGLLightSet(Long_t nElements, void *p) {
      return p ? new(p) ::TGLLightSet[nElements] : new ::TGLLightSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLLightSet(void *p) {
      delete ((::TGLLightSet*)p);
   }
   static void deleteArray_TGLLightSet(void *p) {
      delete [] ((::TGLLightSet*)p);
   }
   static void destruct_TGLLightSet(void *p) {
      typedef ::TGLLightSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLLightSet

//______________________________________________________________________________
void TGLLightSetEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLLightSetEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLLightSetEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLLightSetEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TGLLightSetEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLLightSetEditor.
      TClass *R__cl = ::TGLLightSetEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSE", &fSE);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLLightSetEditor(void *p) {
      return  p ? new(p) ::TGLLightSetEditor : new ::TGLLightSetEditor;
   }
   static void *newArray_TGLLightSetEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGLLightSetEditor[nElements] : new ::TGLLightSetEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLLightSetEditor(void *p) {
      delete ((::TGLLightSetEditor*)p);
   }
   static void deleteArray_TGLLightSetEditor(void *p) {
      delete [] ((::TGLLightSetEditor*)p);
   }
   static void destruct_TGLLightSetEditor(void *p) {
      typedef ::TGLLightSetEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLLightSetEditor

//______________________________________________________________________________
void TGLLightSetSubEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLLightSetSubEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLLightSetSubEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLLightSetSubEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TGLLightSetSubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLLightSetSubEditor.
      TClass *R__cl = ::TGLLightSetSubEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLightFrame", &fLightFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopLight", &fTopLight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRightLight", &fRightLight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBottomLight", &fBottomLight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeftLight", &fLeftLight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrontLight", &fFrontLight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSpecularLight", &fSpecularLight);
      TGVerticalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLLightSetSubEditor(void *p) {
      delete ((::TGLLightSetSubEditor*)p);
   }
   static void deleteArray_TGLLightSetSubEditor(void *p) {
      delete [] ((::TGLLightSetSubEditor*)p);
   }
   static void destruct_TGLLightSetSubEditor(void *p) {
      typedef ::TGLLightSetSubEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLLightSetSubEditor

//______________________________________________________________________________
void TGLOutput::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLOutput.

   ::Error("TGLOutput::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLOutput::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLOutput.
      TClass *R__cl = ::TGLOutput::IsA();
      if (R__cl || R__insp.IsA()) { }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLOutput(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLOutput : new ::TGLOutput;
   }
   static void *newArray_TGLOutput(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLOutput[nElements] : new ::TGLOutput[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLOutput(void *p) {
      delete ((::TGLOutput*)p);
   }
   static void deleteArray_TGLOutput(void *p) {
      delete [] ((::TGLOutput*)p);
   }
   static void destruct_TGLOutput(void *p) {
      typedef ::TGLOutput current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLOutput(TBuffer &buf, void *obj) {
      ((::TGLOutput*)obj)->::TGLOutput::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLOutput

//______________________________________________________________________________
void TArcBall::Streamer(TBuffer &R__b)
{
   // Stream an object of class TArcBall.

   ::Error("TArcBall::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TArcBall::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TArcBall.
      TClass *R__cl = ::TArcBall::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThisRot[9]", fThisRot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastRot[9]", fLastRot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransform[16]", fTransform);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStVec[3]", fStVec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnVec[3]", fEnVec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdjustWidth", &fAdjustWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdjustHeight", &fAdjustHeight);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArcBall(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArcBall : new ::TArcBall;
   }
   static void *newArray_TArcBall(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArcBall[nElements] : new ::TArcBall[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArcBall(void *p) {
      delete ((::TArcBall*)p);
   }
   static void deleteArray_TArcBall(void *p) {
      delete [] ((::TArcBall*)p);
   }
   static void destruct_TArcBall(void *p) {
      typedef ::TArcBall current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArcBall(TBuffer &buf, void *obj) {
      ((::TArcBall*)obj)->::TArcBall::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArcBall

//______________________________________________________________________________
void TGLFaceSet::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLFaceSet.

   TGLLogicalShape::Streamer(R__b);
}

//______________________________________________________________________________
void TGLFaceSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLFaceSet.
      TClass *R__cl = ::TGLFaceSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVertices", (void*)&fVertices);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVertices, "fVertices.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormals", (void*)&fNormals);
      R__insp.InspectMember("vector<Double_t>", (void*)&fNormals, "fNormals.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolyDesc", (void*)&fPolyDesc);
      R__insp.InspectMember("vector<Int_t>", (void*)&fPolyDesc, "fPolyDesc.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbPols", &fNbPols);
      TGLLogicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLFaceSet(void *p) {
      delete ((::TGLFaceSet*)p);
   }
   static void deleteArray_TGLFaceSet(void *p) {
      delete [] ((::TGLFaceSet*)p);
   }
   static void destruct_TGLFaceSet(void *p) {
      typedef ::TGLFaceSet current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLFaceSet(TBuffer &buf, void *obj) {
      ((::TGLFaceSet*)obj)->::TGLFaceSet::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLFaceSet

//______________________________________________________________________________
void TGLPolyLine::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPolyLine.

   TGLLogicalShape::Streamer(R__b);
}

//______________________________________________________________________________
void TGLPolyLine::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPolyLine.
      TClass *R__cl = ::TGLPolyLine::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVertices", (void*)&fVertices);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVertices, "fVertices.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineWidth", &fLineWidth);
      TGLLogicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPolyLine(void *p) {
      delete ((::TGLPolyLine*)p);
   }
   static void deleteArray_TGLPolyLine(void *p) {
      delete [] ((::TGLPolyLine*)p);
   }
   static void destruct_TGLPolyLine(void *p) {
      typedef ::TGLPolyLine current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPolyLine(TBuffer &buf, void *obj) {
      ((::TGLPolyLine*)obj)->::TGLPolyLine::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPolyLine

//______________________________________________________________________________
void TGLPolyMarker::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPolyMarker.

   TGLLogicalShape::Streamer(R__b);
}

//______________________________________________________________________________
void TGLPolyMarker::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPolyMarker.
      TClass *R__cl = ::TGLPolyMarker::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVertices", (void*)&fVertices);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVertices, "fVertices.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyle", &fStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      TGLLogicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPolyMarker(void *p) {
      delete ((::TGLPolyMarker*)p);
   }
   static void deleteArray_TGLPolyMarker(void *p) {
      delete [] ((::TGLPolyMarker*)p);
   }
   static void destruct_TGLPolyMarker(void *p) {
      typedef ::TGLPolyMarker current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPolyMarker(TBuffer &buf, void *obj) {
      ((::TGLPolyMarker*)obj)->::TGLPolyMarker::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPolyMarker

//______________________________________________________________________________
void TGLCylinder::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLCylinder.

   TGLLogicalShape::Streamer(R__b);
}

//______________________________________________________________________________
void TGLCylinder::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLCylinder.
      TClass *R__cl = ::TGLCylinder::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR1", &fR1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR2", &fR2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR3", &fR3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR4", &fR4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi2", &fPhi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowPlaneNorm", &fLowPlaneNorm);
      R__insp.InspectMember(fLowPlaneNorm, "fLowPlaneNorm.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighPlaneNorm", &fHighPlaneNorm);
      R__insp.InspectMember(fHighPlaneNorm, "fHighPlaneNorm.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSegMesh", &fSegMesh);
      TGLLogicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLCylinder(void *p) {
      delete ((::TGLCylinder*)p);
   }
   static void deleteArray_TGLCylinder(void *p) {
      delete [] ((::TGLCylinder*)p);
   }
   static void destruct_TGLCylinder(void *p) {
      typedef ::TGLCylinder current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLCylinder(TBuffer &buf, void *obj) {
      ((::TGLCylinder*)obj)->::TGLCylinder::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLCylinder

//______________________________________________________________________________
void TGLSphere::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSphere.

   TGLLogicalShape::Streamer(R__b);
}

//______________________________________________________________________________
void TGLSphere::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSphere.
      TClass *R__cl = ::TGLSphere::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadius", &fRadius);
      TGLLogicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLSphere(void *p) {
      delete ((::TGLSphere*)p);
   }
   static void deleteArray_TGLSphere(void *p) {
      delete [] ((::TGLSphere*)p);
   }
   static void destruct_TGLSphere(void *p) {
      typedef ::TGLSphere current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLSphere(TBuffer &buf, void *obj) {
      ((::TGLSphere*)obj)->::TGLSphere::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLSphere

//______________________________________________________________________________
void TGLText::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLText.

   TAttText::Streamer(R__b);
}

//______________________________________________________________________________
void TGLText::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLText.
      TClass *R__cl = ::TGLText::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(), "fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle1", &fAngle1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle2", &fAngle2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle3", &fAngle3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLTextFont", &fGLTextFont);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLText(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLText : new ::TGLText;
   }
   static void *newArray_TGLText(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLText[nElements] : new ::TGLText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLText(void *p) {
      delete ((::TGLText*)p);
   }
   static void deleteArray_TGLText(void *p) {
      delete [] ((::TGLText*)p);
   }
   static void destruct_TGLText(void *p) {
      typedef ::TGLText current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLText(TBuffer &buf, void *obj) {
      ((::TGLText*)obj)->::TGLText::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLText

//______________________________________________________________________________
void TGLAxis::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLAxis.

   TAttLine::Streamer(R__b);
   TAttText::Streamer(R__b);
}

//______________________________________________________________________________
void TGLAxis::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLAxis.
      TClass *R__cl = ::TGLAxis::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDiv", &fNDiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDiv1", &fNDiv1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDiv2", &fNDiv2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDiv3", &fNDiv3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTicks1", &fNTicks1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTicks2", &fNTicks2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTicks1", &fTicks1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTicks2", &fTicks2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabels", &fLabels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisLength", &fAxisLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWmin", &fWmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWmax", &fWmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTickMarksLength", &fTickMarksLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTickMarksOrientation", &fTickMarksOrientation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelsOffset", &fLabelsOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelsSize", &fLabelsSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridLength", &fGridLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fText", &fText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle1", &fAngle1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle2", &fAngle2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngle3", &fAngle3);
      TAttLine::ShowMembers(R__insp);
      TAttText::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLAxis(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAxis : new ::TGLAxis;
   }
   static void *newArray_TGLAxis(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAxis[nElements] : new ::TGLAxis[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLAxis(void *p) {
      delete ((::TGLAxis*)p);
   }
   static void deleteArray_TGLAxis(void *p) {
      delete [] ((::TGLAxis*)p);
   }
   static void destruct_TGLAxis(void *p) {
      typedef ::TGLAxis current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLAxis(TBuffer &buf, void *obj) {
      ((::TGLAxis*)obj)->::TGLAxis::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLAxis

//______________________________________________________________________________
void TGLAxisPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLAxisPainter.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLAxisPainter::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLAxisPainter::Class(),this);
   }
}

//______________________________________________________________________________
void TGLAxisPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLAxisPainter.
      TClass *R__cl = ::TGLAxisPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExp", &fExp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDigits", &fMaxDigits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDecimals", &fDecimals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFormat", &fFormat);
      R__insp.InspectMember(fFormat, "fFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelFont", &fLabelFont);
      R__insp.InspectMember(fLabelFont, "fLabelFont.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitleFont", &fTitleFont);
      R__insp.InspectMember(fTitleFont, "fTitleFont.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttAxis", &fAttAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseAxisColors", &fUseAxisColors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontMode", &fFontMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabVec", (void*)&fLabVec);
      R__insp.InspectMember("TGLAxisPainter::LabVec_t", (void*)&fLabVec, "fLabVec.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMVec", (void*)&fTMVec);
      R__insp.InspectMember("TGLAxisPainter::TMVec_t", (void*)&fTMVec, "fTMVec.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
      R__insp.InspectMember(fDir, "fDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMOff[3]", fTMOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMNDim", &fTMNDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelPixelFontSize", &fLabelPixelFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel3DFontSize", &fLabel3DFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePixelFontSize", &fTitlePixelFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle3DFontSize", &fTitle3DFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelAlignH", &fLabelAlignH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelAlignV", &fLabelAlignV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePos", &fTitlePos);
      R__insp.InspectMember(fTitlePos, "fTitlePos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllZeroesRE", &fAllZeroesRE);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLAxisPainter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAxisPainter : new ::TGLAxisPainter;
   }
   static void *newArray_TGLAxisPainter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAxisPainter[nElements] : new ::TGLAxisPainter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLAxisPainter(void *p) {
      delete ((::TGLAxisPainter*)p);
   }
   static void deleteArray_TGLAxisPainter(void *p) {
      delete [] ((::TGLAxisPainter*)p);
   }
   static void destruct_TGLAxisPainter(void *p) {
      typedef ::TGLAxisPainter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLAxisPainter

//______________________________________________________________________________
void TGLAxisPainterBox::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLAxisPainterBox.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLAxisPainterBox::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLAxisPainterBox::Class(),this);
   }
}

//______________________________________________________________________________
void TGLAxisPainterBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLAxisPainterBox.
      TClass *R__cl = ::TGLAxisPainterBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisTitlePos[3]", fAxisTitlePos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxis[3]", &fAxis);
      TGLAxisPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLAxisPainterBox(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAxisPainterBox : new ::TGLAxisPainterBox;
   }
   static void *newArray_TGLAxisPainterBox(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAxisPainterBox[nElements] : new ::TGLAxisPainterBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLAxisPainterBox(void *p) {
      delete ((::TGLAxisPainterBox*)p);
   }
   static void deleteArray_TGLAxisPainterBox(void *p) {
      delete [] ((::TGLAxisPainterBox*)p);
   }
   static void destruct_TGLAxisPainterBox(void *p) {
      typedef ::TGLAxisPainterBox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLAxisPainterBox

//______________________________________________________________________________
void TGLSelectionBuffer::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSelectionBuffer.

   ::Error("TGLSelectionBuffer::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLSelectionBuffer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSelectionBuffer.
      TClass *R__cl = ::TGLSelectionBuffer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuffer", (void*)&fBuffer);
      R__insp.InspectMember("vector<UChar_t>", (void*)&fBuffer, "fBuffer.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWidth", &fWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeight", &fHeight);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLSelectionBuffer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectionBuffer : new ::TGLSelectionBuffer;
   }
   static void *newArray_TGLSelectionBuffer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLSelectionBuffer[nElements] : new ::TGLSelectionBuffer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLSelectionBuffer(void *p) {
      delete ((::TGLSelectionBuffer*)p);
   }
   static void deleteArray_TGLSelectionBuffer(void *p) {
      delete [] ((::TGLSelectionBuffer*)p);
   }
   static void destruct_TGLSelectionBuffer(void *p) {
      typedef ::TGLSelectionBuffer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLSelectionBuffer(TBuffer &buf, void *obj) {
      ((::TGLSelectionBuffer*)obj)->::TGLSelectionBuffer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLSelectionBuffer

//______________________________________________________________________________
void TGLPlotCoordinates::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPlotCoordinates.

   ::Error("TGLPlotCoordinates::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLPlotCoordinates::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPlotCoordinates.
      TClass *R__cl = ::TGLPlotCoordinates::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordType", &fCoordType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXBins", (void*)&fXBins);
      R__insp.InspectMember("Rgl::BinRange_t", (void*)&fXBins, "fXBins.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYBins", (void*)&fYBins);
      R__insp.InspectMember("Rgl::BinRange_t", (void*)&fYBins, "fYBins.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZBins", (void*)&fZBins);
      R__insp.InspectMember("Rgl::BinRange_t", (void*)&fZBins, "fZBins.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXScale", &fXScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYScale", &fYScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZScale", &fZScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXRange", (void*)&fXRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fXRange, "fXRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYRange", (void*)&fYRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fYRange, "fYRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRange", (void*)&fZRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fZRange, "fZRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXRangeScaled", (void*)&fXRangeScaled);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fXRangeScaled, "fXRangeScaled.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYRangeScaled", (void*)&fYRangeScaled);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fYRangeScaled, "fYRangeScaled.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRangeScaled", (void*)&fZRangeScaled);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fZRangeScaled, "fZRangeScaled.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXLog", &fXLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYLog", &fYLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZLog", &fZLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModified", &fModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFactor", &fFactor);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPlotCoordinates(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPlotCoordinates : new ::TGLPlotCoordinates;
   }
   static void *newArray_TGLPlotCoordinates(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPlotCoordinates[nElements] : new ::TGLPlotCoordinates[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPlotCoordinates(void *p) {
      delete ((::TGLPlotCoordinates*)p);
   }
   static void deleteArray_TGLPlotCoordinates(void *p) {
      delete [] ((::TGLPlotCoordinates*)p);
   }
   static void destruct_TGLPlotCoordinates(void *p) {
      typedef ::TGLPlotCoordinates current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPlotCoordinates(TBuffer &buf, void *obj) {
      ((::TGLPlotCoordinates*)obj)->::TGLPlotCoordinates::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPlotCoordinates

//______________________________________________________________________________
void TGLSurfacePainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLSurfacePainter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLSurfacePainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLSurfacePainter.
      TClass *R__cl = ::TGLSurfacePainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMesh", (void*)&fMesh);
      R__insp.InspectMember("TGL2DArray<TGLVertex3>", (void*)&fMesh, "fMesh.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTexMap", (void*)&fTexMap);
      R__insp.InspectMember("TGL2DArray<Double_t>", (void*)&fTexMap, "fTexMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFaceNormals", (void*)&fFaceNormals);
      R__insp.InspectMember("TGL2DArray<std::pair<TGLVector3,TGLVector3> >", (void*)&fFaceNormals, "fFaceNormals.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAverageNormals", (void*)&fAverageNormals);
      R__insp.InspectMember("TGL2DArray<TGLVector3>", (void*)&fAverageNormals, "fAverageNormals.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fObjectInfo", &fObjectInfo);
      R__insp.InspectMember(fObjectInfo, "fObjectInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProj", (void*)&fProj);
      R__insp.InspectMember("TGLSurfacePainter::Projection_t", (void*)&fProj, "fProj.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOZProj", (void*)&fXOZProj);
      R__insp.InspectMember("list<Projection_t>", (void*)&fXOZProj, "fXOZProj.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOZProj", (void*)&fYOZProj);
      R__insp.InspectMember("list<Projection_t>", (void*)&fYOZProj, "fYOZProj.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOYProj", (void*)&fXOYProj);
      R__insp.InspectMember("list<Projection_t>", (void*)&fXOYProj, "fXOYProj.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPalette", (void*)&fPalette);
      R__insp.InspectMember("TGLLevelPalette", (void*)&fPalette, "fPalette.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorLevels", (void*)&fColorLevels);
      R__insp.InspectMember("vector<Double_t>", (void*)&fColorLevels, "fColorLevels.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinMaxVal", (void*)&fMinMaxVal);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fMinMaxVal, "fMinMaxVal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSectionPass", &fSectionPass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdateTexMap", &fUpdateTexMap);
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLSurfacePainter(void *p) {
      delete ((::TGLSurfacePainter*)p);
   }
   static void deleteArray_TGLSurfacePainter(void *p) {
      delete [] ((::TGLSurfacePainter*)p);
   }
   static void destruct_TGLSurfacePainter(void *p) {
      typedef ::TGLSurfacePainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLSurfacePainter(TBuffer &buf, void *obj) {
      ((::TGLSurfacePainter*)obj)->::TGLSurfacePainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLSurfacePainter

//______________________________________________________________________________
void TGLHistPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLHistPainter.

   TVirtualHistPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLHistPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLHistPainter.
      TClass *R__cl = ::TGLHistPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultPainter", (void*)&fDefaultPainter);
      R__insp.InspectMember("auto_ptr<TVirtualHistPainter>", (void*)&fDefaultPainter, "fDefaultPainter.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGLPainter", (void*)&fGLPainter);
      R__insp.InspectMember("auto_ptr<TGLPlotPainter>", (void*)&fGLPainter, "fGLPainter.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEq", &fEq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF3", &fF3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStack", &fStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlotType", &fPlotType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCamera", &fCamera);
      R__insp.InspectMember(fCamera, "fCamera.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoord", &fCoord);
      R__insp.InspectMember(fCoord, "fCoord.");
      TVirtualHistPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLHistPainter(void *p) {
      delete ((::TGLHistPainter*)p);
   }
   static void deleteArray_TGLHistPainter(void *p) {
      delete [] ((::TGLHistPainter*)p);
   }
   static void destruct_TGLHistPainter(void *p) {
      typedef ::TGLHistPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLHistPainter(TBuffer &buf, void *obj) {
      ((::TGLHistPainter*)obj)->::TGLHistPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLHistPainter

//______________________________________________________________________________
void TGLLegoPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLLegoPainter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLLegoPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLLegoPainter.
      TClass *R__cl = ::TGLLegoPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLegoType", &fLegoType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinZ", &fMinZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinMaxVal", (void*)&fMinMaxVal);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fMinMaxVal, "fMinMaxVal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXEdges", (void*)&fXEdges);
      R__insp.InspectMember("vector<Rgl::Range_t>", (void*)&fXEdges, "fXEdges.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYEdges", (void*)&fYEdges);
      R__insp.InspectMember("vector<Rgl::Range_t>", (void*)&fYEdges, "fYEdges.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosSinTableX", (void*)&fCosSinTableX);
      R__insp.InspectMember("vector<pair<double,double>,allocator<pair<double,double> > >", (void*)&fCosSinTableX, "fCosSinTableX.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosSinTableY", (void*)&fCosSinTableY);
      R__insp.InspectMember("vector<pair<double,double>,allocator<pair<double,double> > >", (void*)&fCosSinTableY, "fCosSinTableY.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinInfo", &fBinInfo);
      R__insp.InspectMember(fBinInfo, "fBinInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuadric", &fQuadric);
      R__insp.InspectMember(fQuadric, "fQuadric.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawErrors", &fDrawErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPalette", (void*)&fPalette);
      R__insp.InspectMember("TGLLevelPalette", (void*)&fPalette, "fPalette.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorLevels", (void*)&fColorLevels);
      R__insp.InspectMember("vector<Double_t>", (void*)&fColorLevels, "fColorLevels.", false);
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLLegoPainter(void *p) {
      delete ((::TGLLegoPainter*)p);
   }
   static void deleteArray_TGLLegoPainter(void *p) {
      delete [] ((::TGLLegoPainter*)p);
   }
   static void destruct_TGLLegoPainter(void *p) {
      typedef ::TGLLegoPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLLegoPainter(TBuffer &buf, void *obj) {
      ((::TGLLegoPainter*)obj)->::TGLLegoPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLLegoPainter

//______________________________________________________________________________
void TGLPlotPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPlotPainter.

   TVirtualGLPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLPlotPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPlotPainter.
      TClass *R__cl = ::TGLPlotPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadColor", &fPadColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadPhi", &fPadPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadTheta", &fPadTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXAxis", &fXAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYAxis", &fYAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZAxis", &fZAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoord", &fCoord);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCamera", &fCamera);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelection", &fSelection);
      R__insp.InspectMember(fSelection, "fSelection.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdateSelection", &fUpdateSelection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectionPass", &fSelectionPass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectedPart", &fSelectedPart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMousePosition", (void*)&fMousePosition);
      R__insp.InspectMember("TPoint", (void*)&fMousePosition, "fMousePosition.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOZSectionPos", &fXOZSectionPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOZSectionPos", &fYOZSectionPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOYSectionPos", &fXOYSectionPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackBox", &fBackBox);
      R__insp.InspectMember(fBackBox, "fBackBox.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoxCut", &fBoxCut);
      R__insp.InspectMember(fBoxCut, "fBoxCut.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZLevels", (void*)&fZLevels);
      R__insp.InspectMember("vector<Double_t>", (void*)&fZLevels, "fZLevels.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighColor", &fHighColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectionBase", &fSelectionBase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawPalette", &fDrawPalette);
      TVirtualGLPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPlotPainter(void *p) {
      delete ((::TGLPlotPainter*)p);
   }
   static void deleteArray_TGLPlotPainter(void *p) {
      delete [] ((::TGLPlotPainter*)p);
   }
   static void destruct_TGLPlotPainter(void *p) {
      typedef ::TGLPlotPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPlotPainter(TBuffer &buf, void *obj) {
      ((::TGLPlotPainter*)obj)->::TGLPlotPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPlotPainter

//______________________________________________________________________________
void TGLBoxPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLBoxPainter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLBoxPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLBoxPainter.
      TClass *R__cl = ::TGLBoxPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOZSlice", &fXOZSlice);
      R__insp.InspectMember(fXOZSlice, "fXOZSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOZSlice", &fYOZSlice);
      R__insp.InspectMember(fYOZSlice, "fYOZSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOYSlice", &fXOYSlice);
      R__insp.InspectMember(fXOYSlice, "fXOYSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlotInfo", &fPlotInfo);
      R__insp.InspectMember(fPlotInfo, "fPlotInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinMaxVal", (void*)&fMinMaxVal);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fMinMaxVal, "fMinMaxVal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuadric", &fQuadric);
      R__insp.InspectMember(fQuadric, "fQuadric.");
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLBoxPainter(void *p) {
      delete ((::TGLBoxPainter*)p);
   }
   static void deleteArray_TGLBoxPainter(void *p) {
      delete [] ((::TGLBoxPainter*)p);
   }
   static void destruct_TGLBoxPainter(void *p) {
      typedef ::TGLBoxPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLBoxPainter(TBuffer &buf, void *obj) {
      ((::TGLBoxPainter*)obj)->::TGLBoxPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLBoxPainter

//______________________________________________________________________________
void TGLTF3Painter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLTF3Painter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLTF3Painter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLTF3Painter.
      TClass *R__cl = ::TGLTF3Painter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyle", &fStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMesh", (void*)&fMesh);
      R__insp.InspectMember("Rgl::Mc::TIsoMesh<double>", (void*)&fMesh, "fMesh.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF3", &fF3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOZSlice", &fXOZSlice);
      R__insp.InspectMember(fXOZSlice, "fXOZSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOZSlice", &fYOZSlice);
      R__insp.InspectMember(fYOZSlice, "fYOZSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOYSlice", &fXOYSlice);
      R__insp.InspectMember(fXOYSlice, "fXOYSlice.");
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLTF3Painter(void *p) {
      delete ((::TGLTF3Painter*)p);
   }
   static void deleteArray_TGLTF3Painter(void *p) {
      delete [] ((::TGLTF3Painter*)p);
   }
   static void destruct_TGLTF3Painter(void *p) {
      typedef ::TGLTF3Painter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLTF3Painter(TBuffer &buf, void *obj) {
      ((::TGLTF3Painter*)obj)->::TGLTF3Painter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLTF3Painter

//______________________________________________________________________________
void TGLIsoPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLIsoPainter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLIsoPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLIsoPainter.
      TClass *R__cl = ::TGLIsoPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOZSlice", &fXOZSlice);
      R__insp.InspectMember(fXOZSlice, "fXOZSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOZSlice", &fYOZSlice);
      R__insp.InspectMember(fYOZSlice, "fYOZSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOYSlice", &fXOYSlice);
      R__insp.InspectMember(fXOYSlice, "fXOYSlice.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDummyMesh", (void*)&fDummyMesh);
      R__insp.InspectMember("TGLIsoPainter::Mesh_t", (void*)&fDummyMesh, "fDummyMesh.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsos", (void*)&fIsos);
      R__insp.InspectMember("TGLIsoPainter::MeshList_t", (void*)&fIsos, "fIsos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCache", (void*)&fCache);
      R__insp.InspectMember("TGLIsoPainter::MeshList_t", (void*)&fCache, "fCache.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinMax", (void*)&fMinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fMinMax, "fMinMax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPalette", (void*)&fPalette);
      R__insp.InspectMember("TGLLevelPalette", (void*)&fPalette, "fPalette.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorLevels", (void*)&fColorLevels);
      R__insp.InspectMember("vector<Double_t>", (void*)&fColorLevels, "fColorLevels.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInit", &fInit);
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLIsoPainter(void *p) {
      delete ((::TGLIsoPainter*)p);
   }
   static void deleteArray_TGLIsoPainter(void *p) {
      delete [] ((::TGLIsoPainter*)p);
   }
   static void destruct_TGLIsoPainter(void *p) {
      typedef ::TGLIsoPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLIsoPainter(TBuffer &buf, void *obj) {
      ((::TGLIsoPainter*)obj)->::TGLIsoPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLIsoPainter

//______________________________________________________________________________
void TGLPlotBox::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPlotBox.

   ::Error("TGLPlotBox::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLPlotBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPlotBox.
      TClass *R__cl = ::TGLPlotBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameColor", &fFrameColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOYSelectable", &fXOYSelectable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOZSelectable", &fXOZSelectable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOZSelectable", &fYOZSelectable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectablePairs[4][2]", fSelectablePairs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "f3DBox[8]", f3DBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "f2DBox[8]", f2DBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "f2DBoxU[8]", f2DBoxU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrontPoint", &fFrontPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangeXU", &fRangeXU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangeYU", &fRangeYU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangeZU", &fRangeZU);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPlotBox(void *p) {
      delete ((::TGLPlotBox*)p);
   }
   static void deleteArray_TGLPlotBox(void *p) {
      delete [] ((::TGLPlotBox*)p);
   }
   static void destruct_TGLPlotBox(void *p) {
      typedef ::TGLPlotBox current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPlotBox(TBuffer &buf, void *obj) {
      ((::TGLPlotBox*)obj)->::TGLPlotBox::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPlotBox

//______________________________________________________________________________
void TGLTH3Slice::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLTH3Slice.

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TGLTH3Slice::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLTH3Slice.
      TClass *R__cl = ::TGLTH3Slice::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisType", &fAxisType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxis", &fAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPalette", (void*)&fPalette);
      R__insp.InspectMember("TGLLevelPalette", (void*)&fPalette, "fPalette.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoord", &fCoord);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBox", &fBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliceWidth", &fSliceWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF3", &fF3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTexCoords", (void*)&fTexCoords);
      R__insp.InspectMember("TGL2DArray<Double_t>", (void*)&fTexCoords, "fTexCoords.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinMax", (void*)&fMinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fMinMax, "fMinMax.", false);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLTH3Slice(void *p) {
      delete ((::TGLTH3Slice*)p);
   }
   static void deleteArray_TGLTH3Slice(void *p) {
      delete [] ((::TGLTH3Slice*)p);
   }
   static void destruct_TGLTH3Slice(void *p) {
      typedef ::TGLTH3Slice current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLTH3Slice(TBuffer &buf, void *obj) {
      ((::TGLTH3Slice*)obj)->::TGLTH3Slice::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLTH3Slice

//______________________________________________________________________________
void TGLBoxCut::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLBoxCut.

   ::Error("TGLBoxCut::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLBoxCut::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLBoxCut.
      TClass *R__cl = ::TGLBoxCut::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXLength", &fXLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYLength", &fYLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZLength", &fZLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCenter", &fCenter);
      R__insp.InspectMember(fCenter, "fCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXRange", (void*)&fXRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fXRange, "fXRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYRange", (void*)&fYRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fYRange, "fYRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRange", (void*)&fZRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fZRange, "fZRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlotBox", &fPlotBox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFactor", &fFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMousePos", (void*)&fMousePos);
      R__insp.InspectMember("TPoint", (void*)&fMousePos, "fMousePos.", false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLBoxCut(void *p) {
      delete ((::TGLBoxCut*)p);
   }
   static void deleteArray_TGLBoxCut(void *p) {
      delete [] ((::TGLBoxCut*)p);
   }
   static void destruct_TGLBoxCut(void *p) {
      typedef ::TGLBoxCut current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLBoxCut(TBuffer &buf, void *obj) {
      ((::TGLBoxCut*)obj)->::TGLBoxCut::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLBoxCut

//______________________________________________________________________________
void TGLParametricEquation::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLParametricEquation.

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TGLParametricEquation::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLParametricEquation.
      TClass *R__cl = ::TGLParametricEquation::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXEquation", (void*)&fXEquation);
      R__insp.InspectMember("TGLParametricEquation::Ptr_t", (void*)&fXEquation, "fXEquation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYEquation", (void*)&fYEquation);
      R__insp.InspectMember("TGLParametricEquation::Ptr_t", (void*)&fYEquation, "fYEquation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZEquation", (void*)&fZEquation);
      R__insp.InspectMember("TGLParametricEquation::Ptr_t", (void*)&fZEquation, "fZEquation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEquation", &fEquation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fURange", (void*)&fURange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fURange, "fURange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVRange", (void*)&fVRange);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fVRange, "fVRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConstrained", &fConstrained);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModified", &fModified);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPainter", (void*)&fPainter);
      R__insp.InspectMember("TGLParametricEquation::Painter_t", (void*)&fPainter, "fPainter.", false);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLParametricEquation(void *p) {
      delete ((::TGLParametricEquation*)p);
   }
   static void deleteArray_TGLParametricEquation(void *p) {
      delete [] ((::TGLParametricEquation*)p);
   }
   static void destruct_TGLParametricEquation(void *p) {
      typedef ::TGLParametricEquation current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLParametricEquation(TBuffer &buf, void *obj) {
      ((::TGLParametricEquation*)obj)->::TGLParametricEquation::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLParametricEquation

//______________________________________________________________________________
void TGLParametricPlot::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLParametricPlot.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLParametricPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLParametricPlot.
      TClass *R__cl = ::TGLParametricPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeshSize", &fMeshSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMesh", (void*)&fMesh);
      R__insp.InspectMember("TGLParametricPlot::TGL2DArray<Vertex_t>", (void*)&fMesh, "fMesh.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowMesh", &fShowMesh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorScheme", &fColorScheme);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEquation", &fEquation);
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLParametricPlot(void *p) {
      delete ((::TGLParametricPlot*)p);
   }
   static void deleteArray_TGLParametricPlot(void *p) {
      delete [] ((::TGLParametricPlot*)p);
   }
   static void destruct_TGLParametricPlot(void *p) {
      typedef ::TGLParametricPlot current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLParametricPlot(TBuffer &buf, void *obj) {
      ((::TGLParametricPlot*)obj)->::TGLParametricPlot::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLParametricPlot

//______________________________________________________________________________
void TGLAdapter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLAdapter.

   TGLPaintDevice::Streamer(R__b);
}

//______________________________________________________________________________
void TGLAdapter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLAdapter.
      TClass *R__cl = ::TGLAdapter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGLDevice", &fGLDevice);
      TGLPaintDevice::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLAdapter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAdapter : new ::TGLAdapter;
   }
   static void *newArray_TGLAdapter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLAdapter[nElements] : new ::TGLAdapter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLAdapter(void *p) {
      delete ((::TGLAdapter*)p);
   }
   static void deleteArray_TGLAdapter(void *p) {
      delete [] ((::TGLAdapter*)p);
   }
   static void destruct_TGLAdapter(void *p) {
      typedef ::TGLAdapter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLAdapter(TBuffer &buf, void *obj) {
      ((::TGLAdapter*)obj)->::TGLAdapter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLAdapter

//______________________________________________________________________________
void TF2GL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TF2GL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TF2GL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TF2GL::Class(),this);
   }
}

//______________________________________________________________________________
void TF2GL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TF2GL.
      TClass *R__cl = ::TF2GL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fH", &fH);
      TGLPlot3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TF2GL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TF2GL : new ::TF2GL;
   }
   static void *newArray_TF2GL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TF2GL[nElements] : new ::TF2GL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TF2GL(void *p) {
      delete ((::TF2GL*)p);
   }
   static void deleteArray_TF2GL(void *p) {
      delete [] ((::TF2GL*)p);
   }
   static void destruct_TF2GL(void *p) {
      typedef ::TF2GL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TF2GL

//______________________________________________________________________________
void TH2GL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH2GL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TH2GL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TH2GL::Class(),this);
   }
}

//______________________________________________________________________________
void TH2GL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH2GL.
      TClass *R__cl = ::TH2GL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      TGLPlot3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2GL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TH2GL : new ::TH2GL;
   }
   static void *newArray_TH2GL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TH2GL[nElements] : new ::TH2GL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2GL(void *p) {
      delete ((::TH2GL*)p);
   }
   static void deleteArray_TH2GL(void *p) {
      delete [] ((::TH2GL*)p);
   }
   static void destruct_TH2GL(void *p) {
      typedef ::TH2GL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TH2GL

//______________________________________________________________________________
void TH3GL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH3GL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TH3GL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TH3GL::Class(),this);
   }
}

//______________________________________________________________________________
void TH3GL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH3GL.
      TClass *R__cl = ::TH3GL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      TGLPlot3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH3GL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TH3GL : new ::TH3GL;
   }
   static void *newArray_TH3GL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TH3GL[nElements] : new ::TH3GL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH3GL(void *p) {
      delete ((::TH3GL*)p);
   }
   static void deleteArray_TH3GL(void *p) {
      delete [] ((::TH3GL*)p);
   }
   static void destruct_TH3GL(void *p) {
      typedef ::TH3GL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TH3GL

//______________________________________________________________________________
void TGLH2PolyPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLH2PolyPainter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLH2PolyPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLH2PolyPainter.
      TClass *R__cl = ::TGLH2PolyPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinInfo", &fBinInfo);
      R__insp.InspectMember(fBinInfo, "fBinInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinColors", (void*)&fBinColors);
      R__insp.InspectMember("vector<Int_t>", (void*)&fBinColors, "fBinColors.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolygon", (void*)&fPolygon);
      R__insp.InspectMember("vector<Double_t>", (void*)&fPolygon, "fPolygon.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCaps", (void*)&fCaps);
      R__insp.InspectMember("list<Rgl::Pad::Tesselation_t>", (void*)&fCaps, "fCaps.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZLog", &fZLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZMin", &fZMin);
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLH2PolyPainter(void *p) {
      delete ((::TGLH2PolyPainter*)p);
   }
   static void deleteArray_TGLH2PolyPainter(void *p) {
      delete [] ((::TGLH2PolyPainter*)p);
   }
   static void destruct_TGLH2PolyPainter(void *p) {
      typedef ::TGLH2PolyPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLH2PolyPainter(TBuffer &buf, void *obj) {
      ((::TGLH2PolyPainter*)obj)->::TGLH2PolyPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLH2PolyPainter

//______________________________________________________________________________
void TGLParametricEquationGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLParametricEquationGL.

   TGLPlot3D::Streamer(R__b);
}

//______________________________________________________________________________
void TGLParametricEquationGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLParametricEquationGL.
      TClass *R__cl = ::TGLParametricEquationGL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      TGLPlot3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLParametricEquationGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLParametricEquationGL : new ::TGLParametricEquationGL;
   }
   static void *newArray_TGLParametricEquationGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLParametricEquationGL[nElements] : new ::TGLParametricEquationGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLParametricEquationGL(void *p) {
      delete ((::TGLParametricEquationGL*)p);
   }
   static void deleteArray_TGLParametricEquationGL(void *p) {
      delete [] ((::TGLParametricEquationGL*)p);
   }
   static void destruct_TGLParametricEquationGL(void *p) {
      typedef ::TGLParametricEquationGL current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLParametricEquationGL(TBuffer &buf, void *obj) {
      ((::TGLParametricEquationGL*)obj)->::TGLParametricEquationGL::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLParametricEquationGL

//______________________________________________________________________________
void TGLPadPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPadPainter.

   TVirtualPadPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLPadPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPadPainter.
      TClass *R__cl = ::TGLPadPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSSet", (void*)&fSSet);
      R__insp.InspectMember("Rgl::Pad::PolygonStippleSet", (void*)&fSSet, "fSSet.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTess", (void*)&fTess);
      R__insp.InspectMember("Rgl::Pad::Tesselator", (void*)&fTess, "fTess.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarker", (void*)&fMarker);
      R__insp.InspectMember("Rgl::Pad::MarkerPainter", (void*)&fMarker, "fMarker.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimits", (void*)&fLimits);
      R__insp.InspectMember("Rgl::Pad::GLLimits", (void*)&fLimits, "fLimits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVs", (void*)&fVs);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVs, "fVs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFM", &fFM);
      R__insp.InspectMember(fFM, "fFM.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fF", &fF);
      R__insp.InspectMember(fF, "fF.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVp[4]", fVp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoly", (void*)&fPoly);
      R__insp.InspectMember("vector<TPoint>", (void*)&fPoly, "fPoly.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsHollowArea", &fIsHollowArea);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocked", &fLocked);
      TVirtualPadPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLPadPainter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPadPainter : new ::TGLPadPainter;
   }
   static void *newArray_TGLPadPainter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLPadPainter[nElements] : new ::TGLPadPainter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLPadPainter(void *p) {
      delete ((::TGLPadPainter*)p);
   }
   static void deleteArray_TGLPadPainter(void *p) {
      delete [] ((::TGLPadPainter*)p);
   }
   static void destruct_TGLPadPainter(void *p) {
      typedef ::TGLPadPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLPadPainter(TBuffer &buf, void *obj) {
      ((::TGLPadPainter*)obj)->::TGLPadPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLPadPainter

//______________________________________________________________________________
void TGL5DDataSet::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGL5DDataSet.

   TNamed::Streamer(R__b);
}

//______________________________________________________________________________
void TGL5DDataSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGL5DDataSet.
      TClass *R__cl = ::TGL5DDataSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNP", &fNP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV1", &fV1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV2", &fV2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV3", &fV3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV4", &fV4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV5", &fV5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV1MinMax", (void*)&fV1MinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fV1MinMax, "fV1MinMax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV1Range", &fV1Range);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV2MinMax", (void*)&fV2MinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fV2MinMax, "fV2MinMax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV2Range", &fV2Range);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV3MinMax", (void*)&fV3MinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fV3MinMax, "fV3MinMax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV3Range", &fV3Range);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV4MinMax", (void*)&fV4MinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fV4MinMax, "fV4MinMax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV5MinMax", (void*)&fV5MinMax);
      R__insp.InspectMember("Rgl::Range_t", (void*)&fV5MinMax, "fV5MinMax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXAxis", &fXAxis);
      R__insp.InspectMember(fXAxis, "fXAxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYAxis", &fYAxis);
      R__insp.InspectMember(fYAxis, "fYAxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZAxis", &fZAxis);
      R__insp.InspectMember(fZAxis, "fZAxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV4IsString", &fV4IsString);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPainter", (void*)&fPainter);
      R__insp.InspectMember("auto_ptr<TGLHistPainter>", (void*)&fPainter, "fPainter.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndices", (void*)&fIndices);
      R__insp.InspectMember("vector<UInt_t>", (void*)&fIndices, "fIndices.", false);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGL5DDataSet(void *p) {
      delete ((::TGL5DDataSet*)p);
   }
   static void deleteArray_TGL5DDataSet(void *p) {
      delete [] ((::TGL5DDataSet*)p);
   }
   static void destruct_TGL5DDataSet(void *p) {
      typedef ::TGL5DDataSet current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGL5DDataSet(TBuffer &buf, void *obj) {
      ((::TGL5DDataSet*)obj)->::TGL5DDataSet::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGL5DDataSet

//______________________________________________________________________________
void TGL5DDataSetEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGL5DDataSetEditor.

   TGedFrame::Streamer(R__b);
}

//______________________________________________________________________________
void TGL5DDataSetEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGL5DDataSetEditor.
      TClass *R__cl = ::TGL5DDataSetEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNCellsXEntry", &fNCellsXEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNCellsYEntry", &fNCellsYEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNCellsZEntry", &fNCellsZEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXRangeSlider", &fXRangeSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXRangeSliderMin", &fXRangeSliderMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXRangeSliderMax", &fXRangeSliderMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYRangeSlider", &fYRangeSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYRangeSliderMin", &fYRangeSliderMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYRangeSliderMax", &fYRangeSliderMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZRangeSlider", &fZRangeSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZRangeSliderMin", &fZRangeSliderMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZRangeSliderMax", &fZRangeSliderMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancelGridBtn", &fCancelGridBtn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOkGridBtn", &fOkGridBtn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV4MinEntry", &fV4MinEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fV4MaxEntry", &fV4MaxEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHighlightCheck", &fHighlightCheck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsoList", &fIsoList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVisibleCheck", &fVisibleCheck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShowCloud", &fShowCloud);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSurfColorSelect", &fSurfColorSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSurfAlphaSlider", &fSurfAlphaSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSurfRemoveBtn", &fSurfRemoveBtn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNewIsoEntry", &fNewIsoEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddNewIsoBtn", &fAddNewIsoBtn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShowBoxCut", &fShowBoxCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNumberOfPlanes", &fNumberOfPlanes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogScale", &fLogScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlideRange", &fSlideRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyAlpha", &fApplyAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyPlanes", &fApplyPlanes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSet", &fDataSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPainter", &fPainter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHidden", &fHidden);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelectedSurface", &fSelectedSurface);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGL5DDataSetEditor(void *p) {
      return  p ? new(p) ::TGL5DDataSetEditor : new ::TGL5DDataSetEditor;
   }
   static void *newArray_TGL5DDataSetEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TGL5DDataSetEditor[nElements] : new ::TGL5DDataSetEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGL5DDataSetEditor(void *p) {
      delete ((::TGL5DDataSetEditor*)p);
   }
   static void deleteArray_TGL5DDataSetEditor(void *p) {
      delete [] ((::TGL5DDataSetEditor*)p);
   }
   static void destruct_TGL5DDataSetEditor(void *p) {
      typedef ::TGL5DDataSetEditor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGL5DDataSetEditor(TBuffer &buf, void *obj) {
      ((::TGL5DDataSetEditor*)obj)->::TGL5DDataSetEditor::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGL5DDataSetEditor

//______________________________________________________________________________
void TGLTH3Composition::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLTH3Composition.

   TH3C::Streamer(R__b);
}

//______________________________________________________________________________
void TGLTH3Composition::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLTH3Composition.
      TClass *R__cl = ::TGLTH3Composition::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHists", (void*)&fHists);
      R__insp.InspectMember("vector<TH3Pair_t>", (void*)&fHists, "fHists.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPainter", (void*)&fPainter);
      R__insp.InspectMember("auto_ptr<TGLHistPainter>", (void*)&fPainter, "fPainter.", false);
      TH3C::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLTH3Composition(void *p) {
      return  p ? new(p) ::TGLTH3Composition : new ::TGLTH3Composition;
   }
   static void *newArray_TGLTH3Composition(Long_t nElements, void *p) {
      return p ? new(p) ::TGLTH3Composition[nElements] : new ::TGLTH3Composition[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLTH3Composition(void *p) {
      delete ((::TGLTH3Composition*)p);
   }
   static void deleteArray_TGLTH3Composition(void *p) {
      delete [] ((::TGLTH3Composition*)p);
   }
   static void destruct_TGLTH3Composition(void *p) {
      typedef ::TGLTH3Composition current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TGLTH3Composition(void *p, TDirectory *dir) {
      ((::TGLTH3Composition*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLTH3Composition(TBuffer &buf, void *obj) {
      ((::TGLTH3Composition*)obj)->::TGLTH3Composition::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLTH3Composition

//______________________________________________________________________________
void TGLTH3CompositionPainter::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLTH3CompositionPainter.

   TGLPlotPainter::Streamer(R__b);
}

//______________________________________________________________________________
void TGLTH3CompositionPainter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLTH3CompositionPainter.
      TClass *R__cl = ::TGLTH3CompositionPainter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinMaxVal", (void*)&fMinMaxVal);
      R__insp.InspectMember("pair<Double_t,Double_t>", (void*)&fMinMaxVal, "fMinMaxVal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuadric", &fQuadric);
      R__insp.InspectMember(fQuadric, "fQuadric.");
      TGLPlotPainter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLTH3CompositionPainter(void *p) {
      delete ((::TGLTH3CompositionPainter*)p);
   }
   static void deleteArray_TGLTH3CompositionPainter(void *p) {
      delete [] ((::TGLTH3CompositionPainter*)p);
   }
   static void destruct_TGLTH3CompositionPainter(void *p) {
      typedef ::TGLTH3CompositionPainter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLTH3CompositionPainter(TBuffer &buf, void *obj) {
      ((::TGLTH3CompositionPainter*)obj)->::TGLTH3CompositionPainter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLTH3CompositionPainter

//______________________________________________________________________________
void TX11GLManager::Streamer(TBuffer &R__b)
{
   // Stream an object of class TX11GLManager.

   TGLManager::Streamer(R__b);
}

//______________________________________________________________________________
void TX11GLManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TX11GLManager.
      TClass *R__cl = ::TX11GLManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPimpl", &fPimpl);
      TGLManager::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TX11GLManager(void *p) {
      return  p ? new(p) ::TX11GLManager : new ::TX11GLManager;
   }
   static void *newArray_TX11GLManager(Long_t nElements, void *p) {
      return p ? new(p) ::TX11GLManager[nElements] : new ::TX11GLManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TX11GLManager(void *p) {
      delete ((::TX11GLManager*)p);
   }
   static void deleteArray_TX11GLManager(void *p) {
      delete [] ((::TX11GLManager*)p);
   }
   static void destruct_TX11GLManager(void *p) {
      typedef ::TX11GLManager current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TX11GLManager(TBuffer &buf, void *obj) {
      ((::TX11GLManager*)obj)->::TX11GLManager::Streamer(buf);
   }
} // end of namespace ROOT for class ::TX11GLManager

//______________________________________________________________________________
void TGLObject::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLObject.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLObject::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLObject::Class(),this);
   }
}

//______________________________________________________________________________
void TGLObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLObject.
      TClass *R__cl = ::TGLObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMultiColor", &fMultiColor);
      TGLLogicalShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLObject(void *p) {
      delete ((::TGLObject*)p);
   }
   static void deleteArray_TGLObject(void *p) {
      delete [] ((::TGLObject*)p);
   }
   static void destruct_TGLObject(void *p) {
      typedef ::TGLObject current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLObject

//______________________________________________________________________________
void TGLPlot3D::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLPlot3D.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TGLPlot3D::Class(),this);
   } else {
      R__b.WriteClassBuffer(TGLPlot3D::Class(),this);
   }
}

//______________________________________________________________________________
void TGLPlot3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLPlot3D.
      TClass *R__cl = ::TGLPlot3D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlotPainter", &fPlotPainter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoord", &fCoord);
      R__insp.InspectMember(fCoord, "fCoord.");
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGLPlot3D(void *p) {
      delete ((::TGLPlot3D*)p);
   }
   static void deleteArray_TGLPlot3D(void *p) {
      delete [] ((::TGLPlot3D*)p);
   }
   static void destruct_TGLPlot3D(void *p) {
      typedef ::TGLPlot3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGLPlot3D

//______________________________________________________________________________
void TPointSet3DGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TPointSet3DGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TPointSet3DGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TPointSet3DGL::Class(),this);
   }
}

//______________________________________________________________________________
void TPointSet3DGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPointSet3DGL.
      TClass *R__cl = ::TPointSet3DGL::IsA();
      if (R__cl || R__insp.IsA()) { }
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPointSet3DGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPointSet3DGL : new ::TPointSet3DGL;
   }
   static void *newArray_TPointSet3DGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TPointSet3DGL[nElements] : new ::TPointSet3DGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPointSet3DGL(void *p) {
      delete ((::TPointSet3DGL*)p);
   }
   static void deleteArray_TPointSet3DGL(void *p) {
      delete [] ((::TPointSet3DGL*)p);
   }
   static void destruct_TPointSet3DGL(void *p) {
      typedef ::TPointSet3DGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPointSet3DGL

//______________________________________________________________________________
void TGLFont::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLFont.

   ::Error("TGLFont::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLFont::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLFont.
      TClass *R__cl = ::TGLFont::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(), "*fManager", &fManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDepth", &fDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrashCount", &fTrashCount);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLFont(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFont : new ::TGLFont;
   }
   static void *newArray_TGLFont(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFont[nElements] : new ::TGLFont[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLFont(void *p) {
      delete ((::TGLFont*)p);
   }
   static void deleteArray_TGLFont(void *p) {
      delete [] ((::TGLFont*)p);
   }
   static void destruct_TGLFont(void *p) {
      typedef ::TGLFont current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLFont(TBuffer &buf, void *obj) {
      ((::TGLFont*)obj)->::TGLFont::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLFont

//______________________________________________________________________________
void TGLFontManager::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGLFontManager.

   ::Error("TGLFontManager::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TGLFontManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGLFontManager.
      TClass *R__cl = ::TGLFontManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontMap", (void*)&fFontMap);
      R__insp.InspectMember("TGLFontManager::FontMap_t", (void*)&fFontMap, "fFontMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontTrash", (void*)&fFontTrash);
      R__insp.InspectMember("TGLFontManager::FontList_t", (void*)&fFontTrash, "fFontTrash.", false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGLFontManager(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFontManager : new ::TGLFontManager;
   }
   static void *newArray_TGLFontManager(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGLFontManager[nElements] : new ::TGLFontManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGLFontManager(void *p) {
      delete ((::TGLFontManager*)p);
   }
   static void deleteArray_TGLFontManager(void *p) {
      delete [] ((::TGLFontManager*)p);
   }
   static void destruct_TGLFontManager(void *p) {
      typedef ::TGLFontManager current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGLFontManager(TBuffer &buf, void *obj) {
      ((::TGLFontManager*)obj)->::TGLFontManager::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGLFontManager

namespace ROOT {
   void maplETClassmUcOunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplETClassmUcOunsignedsPintgR_Dictionary();
   static void *new_maplETClassmUcOunsignedsPintgR(void *p = 0);
   static void *newArray_maplETClassmUcOunsignedsPintgR(Long_t size, void *p);
   static void delete_maplETClassmUcOunsignedsPintgR(void *p);
   static void deleteArray_maplETClassmUcOunsignedsPintgR(void *p);
   static void destruct_maplETClassmUcOunsignedsPintgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<TClass*,unsigned int>*)
   {
      map<TClass*,unsigned int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<TClass*,unsigned int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<TClass*,unsigned int>", -2, "prec_stl/map", 63,
                  typeid(map<TClass*,unsigned int>), DefineBehavior(ptr, ptr),
                  0, &maplETClassmUcOunsignedsPintgR_Dictionary, isa_proxy, 0,
                  sizeof(map<TClass*,unsigned int>) );
      instance.SetNew(&new_maplETClassmUcOunsignedsPintgR);
      instance.SetNewArray(&newArray_maplETClassmUcOunsignedsPintgR);
      instance.SetDelete(&delete_maplETClassmUcOunsignedsPintgR);
      instance.SetDeleteArray(&deleteArray_maplETClassmUcOunsignedsPintgR);
      instance.SetDestructor(&destruct_maplETClassmUcOunsignedsPintgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<TClass*,unsigned int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<TClass*,unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplETClassmUcOunsignedsPintgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const map<TClass*,unsigned int>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplETClassmUcOunsignedsPintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<TClass*,unsigned int> : new map<TClass*,unsigned int>;
   }
   static void *newArray_maplETClassmUcOunsignedsPintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<TClass*,unsigned int>[nElements] : new map<TClass*,unsigned int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplETClassmUcOunsignedsPintgR(void *p) {
      delete ((map<TClass*,unsigned int>*)p);
   }
   static void deleteArray_maplETClassmUcOunsignedsPintgR(void *p) {
      delete [] ((map<TClass*,unsigned int>*)p);
   }
   static void destruct_maplETClassmUcOunsignedsPintgR(void *p) {
      typedef map<TClass*,unsigned int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<TClass*,unsigned int>

namespace ROOT {
   void vectorlETGLScenecLcLDrawElement_tmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETGLScenecLcLDrawElement_tmUgR_Dictionary();
   static void *new_vectorlETGLScenecLcLDrawElement_tmUgR(void *p = 0);
   static void *newArray_vectorlETGLScenecLcLDrawElement_tmUgR(Long_t size, void *p);
   static void delete_vectorlETGLScenecLcLDrawElement_tmUgR(void *p);
   static void deleteArray_vectorlETGLScenecLcLDrawElement_tmUgR(void *p);
   static void destruct_vectorlETGLScenecLcLDrawElement_tmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TGLScene::DrawElement_t*>*)
   {
      vector<TGLScene::DrawElement_t*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TGLScene::DrawElement_t*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TGLScene::DrawElement_t*>", -2, "prec_stl/vector", 49,
                  typeid(vector<TGLScene::DrawElement_t*>), DefineBehavior(ptr, ptr),
                  0, &vectorlETGLScenecLcLDrawElement_tmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TGLScene::DrawElement_t*>) );
      instance.SetNew(&new_vectorlETGLScenecLcLDrawElement_tmUgR);
      instance.SetNewArray(&newArray_vectorlETGLScenecLcLDrawElement_tmUgR);
      instance.SetDelete(&delete_vectorlETGLScenecLcLDrawElement_tmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlETGLScenecLcLDrawElement_tmUgR);
      instance.SetDestructor(&destruct_vectorlETGLScenecLcLDrawElement_tmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TGLScene::DrawElement_t*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TGLScene::DrawElement_t*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETGLScenecLcLDrawElement_tmUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TGLScene::DrawElement_t*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETGLScenecLcLDrawElement_tmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TGLScene::DrawElement_t*> : new vector<TGLScene::DrawElement_t*>;
   }
   static void *newArray_vectorlETGLScenecLcLDrawElement_tmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TGLScene::DrawElement_t*>[nElements] : new vector<TGLScene::DrawElement_t*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETGLScenecLcLDrawElement_tmUgR(void *p) {
      delete ((vector<TGLScene::DrawElement_t*>*)p);
   }
   static void deleteArray_vectorlETGLScenecLcLDrawElement_tmUgR(void *p) {
      delete [] ((vector<TGLScene::DrawElement_t*>*)p);
   }
   static void destruct_vectorlETGLScenecLcLDrawElement_tmUgR(void *p) {
      typedef vector<TGLScene::DrawElement_t*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TGLScene::DrawElement_t*>

namespace ROOT {
   void vectorlETGLScenecLcLDrawElement_tgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETGLScenecLcLDrawElement_tgR_Dictionary();
   static void *new_vectorlETGLScenecLcLDrawElement_tgR(void *p = 0);
   static void *newArray_vectorlETGLScenecLcLDrawElement_tgR(Long_t size, void *p);
   static void delete_vectorlETGLScenecLcLDrawElement_tgR(void *p);
   static void deleteArray_vectorlETGLScenecLcLDrawElement_tgR(void *p);
   static void destruct_vectorlETGLScenecLcLDrawElement_tgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TGLScene::DrawElement_t>*)
   {
      vector<TGLScene::DrawElement_t> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TGLScene::DrawElement_t>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TGLScene::DrawElement_t>", -2, "prec_stl/vector", 49,
                  typeid(vector<TGLScene::DrawElement_t>), DefineBehavior(ptr, ptr),
                  0, &vectorlETGLScenecLcLDrawElement_tgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TGLScene::DrawElement_t>) );
      instance.SetNew(&new_vectorlETGLScenecLcLDrawElement_tgR);
      instance.SetNewArray(&newArray_vectorlETGLScenecLcLDrawElement_tgR);
      instance.SetDelete(&delete_vectorlETGLScenecLcLDrawElement_tgR);
      instance.SetDeleteArray(&deleteArray_vectorlETGLScenecLcLDrawElement_tgR);
      instance.SetDestructor(&destruct_vectorlETGLScenecLcLDrawElement_tgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TGLScene::DrawElement_t> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TGLScene::DrawElement_t>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETGLScenecLcLDrawElement_tgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TGLScene::DrawElement_t>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETGLScenecLcLDrawElement_tgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TGLScene::DrawElement_t> : new vector<TGLScene::DrawElement_t>;
   }
   static void *newArray_vectorlETGLScenecLcLDrawElement_tgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TGLScene::DrawElement_t>[nElements] : new vector<TGLScene::DrawElement_t>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETGLScenecLcLDrawElement_tgR(void *p) {
      delete ((vector<TGLScene::DrawElement_t>*)p);
   }
   static void deleteArray_vectorlETGLScenecLcLDrawElement_tgR(void *p) {
      delete [] ((vector<TGLScene::DrawElement_t>*)p);
   }
   static void destruct_vectorlETGLScenecLcLDrawElement_tgR(void *p) {
      typedef vector<TGLScene::DrawElement_t> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TGLScene::DrawElement_t>

namespace ROOT {
   void vectorlEconstsPTGLPhysicalShapemUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEconstsPTGLPhysicalShapemUgR_Dictionary();
   static void *new_vectorlEconstsPTGLPhysicalShapemUgR(void *p = 0);
   static void *newArray_vectorlEconstsPTGLPhysicalShapemUgR(Long_t size, void *p);
   static void delete_vectorlEconstsPTGLPhysicalShapemUgR(void *p);
   static void deleteArray_vectorlEconstsPTGLPhysicalShapemUgR(void *p);
   static void destruct_vectorlEconstsPTGLPhysicalShapemUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const TGLPhysicalShape*>*)
   {
      vector<const TGLPhysicalShape*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const TGLPhysicalShape*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<const TGLPhysicalShape*>", -2, "prec_stl/vector", 49,
                  typeid(vector<const TGLPhysicalShape*>), DefineBehavior(ptr, ptr),
                  0, &vectorlEconstsPTGLPhysicalShapemUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<const TGLPhysicalShape*>) );
      instance.SetNew(&new_vectorlEconstsPTGLPhysicalShapemUgR);
      instance.SetNewArray(&newArray_vectorlEconstsPTGLPhysicalShapemUgR);
      instance.SetDelete(&delete_vectorlEconstsPTGLPhysicalShapemUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEconstsPTGLPhysicalShapemUgR);
      instance.SetDestructor(&destruct_vectorlEconstsPTGLPhysicalShapemUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const TGLPhysicalShape*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<const TGLPhysicalShape*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEconstsPTGLPhysicalShapemUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<const TGLPhysicalShape*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEconstsPTGLPhysicalShapemUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<const TGLPhysicalShape*> : new vector<const TGLPhysicalShape*>;
   }
   static void *newArray_vectorlEconstsPTGLPhysicalShapemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<const TGLPhysicalShape*>[nElements] : new vector<const TGLPhysicalShape*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEconstsPTGLPhysicalShapemUgR(void *p) {
      delete ((vector<const TGLPhysicalShape*>*)p);
   }
   static void deleteArray_vectorlEconstsPTGLPhysicalShapemUgR(void *p) {
      delete [] ((vector<const TGLPhysicalShape*>*)p);
   }
   static void destruct_vectorlEconstsPTGLPhysicalShapemUgR(void *p) {
      typedef vector<const TGLPhysicalShape*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<const TGLPhysicalShape*>

/********************************************************
* graf3d/gl/src/G__GL.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__GL();

extern "C" void G__set_cpp_environmentG__GL() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TArcBall.h");
  G__add_compiledheader("TF2GL.h");
  G__add_compiledheader("TGL5DDataSetEditor.h");
  G__add_compiledheader("TGL5D.h");
  G__add_compiledheader("TGLAdapter.h");
  G__add_compiledheader("TGLAnnotation.h");
  G__add_compiledheader("TGLAutoRotator.h");
  G__add_compiledheader("TGLAxis.h");
  G__add_compiledheader("TGLAxisPainter.h");
  G__add_compiledheader("TGLBoundingBox.h");
  G__add_compiledheader("TGLBoxPainter.h");
  G__add_compiledheader("TGLCameraGuide.h");
  G__add_compiledheader("TGLCamera.h");
  G__add_compiledheader("TGLCameraOverlay.h");
  G__add_compiledheader("TGLClip.h");
  G__add_compiledheader("TGLClipSetEditor.h");
  G__add_compiledheader("TGLContext.h");
  G__add_compiledheader("TGLCylinder.h");
  G__add_compiledheader("TGLEmbeddedViewer.h");
  G__add_compiledheader("TGLEventHandler.h");
  G__add_compiledheader("TGLFaceSet.h");
  G__add_compiledheader("TGLFBO.h");
  G__add_compiledheader("TGLFontManager.h");
  G__add_compiledheader("TGLFormat.h");
  G__add_compiledheader("TGLH2PolyPainter.h");
  G__add_compiledheader("TGLHistPainter.h");
  G__add_compiledheader("TGLLegoPainter.h");
  G__add_compiledheader("TGLLightSetEditor.h");
  G__add_compiledheader("TGLLightSet.h");
  G__add_compiledheader("TGLLockable.h");
  G__add_compiledheader("TGLLogicalShape.h");
  G__add_compiledheader("TGLManip.h");
  G__add_compiledheader("TGLManipSet.h");
  G__add_compiledheader("TGLObject.h");
  G__add_compiledheader("TGLOrthoCamera.h");
  G__add_compiledheader("TGLOutput.h");
  G__add_compiledheader("TGLOverlayButton.h");
  G__add_compiledheader("TGLOverlay.h");
  G__add_compiledheader("TGLPadPainter.h");
  G__add_compiledheader("TGLPadUtils.h");
  G__add_compiledheader("TGLParametricEquationGL.h");
  G__add_compiledheader("TGLParametric.h");
  G__add_compiledheader("TGLPerspectiveCamera.h");
  G__add_compiledheader("TGLPhysicalShape.h");
  G__add_compiledheader("TGLPlot3D.h");
  G__add_compiledheader("TGLPlotBox.h");
  G__add_compiledheader("TGLPlotCamera.h");
  G__add_compiledheader("TGLPlotPainter.h");
  G__add_compiledheader("TGLPolyLine.h");
  G__add_compiledheader("TGLPolyMarker.h");
  G__add_compiledheader("TGLPShapeObjEditor.h");
  G__add_compiledheader("TGLPShapeObj.h");
  G__add_compiledheader("TGLPShapeRef.h");
  G__add_compiledheader("TGLQuadric.h");
  G__add_compiledheader("TGLRnrCtx.h");
  G__add_compiledheader("TGLRotateManip.h");
  G__add_compiledheader("TGLSAFrame.h");
  G__add_compiledheader("TGLSAViewer.h");
  G__add_compiledheader("TGLScaleManip.h");
  G__add_compiledheader("TGLSceneBase.h");
  G__add_compiledheader("TGLScene.h");
  G__add_compiledheader("TGLSceneInfo.h");
  G__add_compiledheader("TGLScenePad.h");
  G__add_compiledheader("TGLSelectBuffer.h");
  G__add_compiledheader("TGLSelectRecord.h");
  G__add_compiledheader("TGLSphere.h");
  G__add_compiledheader("TGLStopwatch.h");
  G__add_compiledheader("TGLSurfacePainter.h");
  G__add_compiledheader("TGLText.h");
  G__add_compiledheader("TGLTF3Painter.h");
  G__add_compiledheader("TGLTH3Composition.h");
  G__add_compiledheader("TGLTransManip.h");
  G__add_compiledheader("TGLUtil.h");
  G__add_compiledheader("TGLViewerBase.h");
  G__add_compiledheader("TGLViewerEditor.h");
  G__add_compiledheader("TGLViewer.h");
  G__add_compiledheader("TGLWidget.h");
  G__add_compiledheader("TH2GL.h");
  G__add_compiledheader("TH3GL.h");
  G__add_compiledheader("TPointSet3DGL.h");
  G__add_compiledheader("TX11GL.h");
  G__cpp_reset_tagtableG__GL();
}
#include <new>
extern "C" int G__cpp_dllrevG__GL() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* TArcBall */
static int G__G__GL_100_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArcBall* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TArcBall((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TArcBall((UInt_t) 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 TArcBall((UInt_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TArcBall((UInt_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TArcBall[n];
       } else {
         p = new((void*) gvp) TArcBall[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TArcBall;
       } else {
         p = new((void*) gvp) TArcBall;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TArcBall));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArcBall*) G__getstructoffset())->SetBounds((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__GL_100_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArcBall*) G__getstructoffset())->Click(*(TPoint*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArcBall*) G__getstructoffset())->Drag(*(TPoint*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TArcBall*) G__getstructoffset())->GetRotMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TArcBall::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TArcBall::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TArcBall::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TArcBall::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TArcBall*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArcBall*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArcBall*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArcBall*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TArcBall::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TArcBall::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TArcBall::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_100_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TArcBall::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TArcBall G__TTArcBall;
static int G__G__GL_100_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TArcBall*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TArcBall*) (soff+(sizeof(TArcBall)*i)))->~G__TTArcBall();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TArcBall*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TArcBall*) (soff))->~G__TTArcBall();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLBoundingBox */
static int G__G__GL_102_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoundingBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLBoundingBox[n];
     } else {
       p = new((void*) gvp) TGLBoundingBox[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLBoundingBox;
     } else {
       p = new((void*) gvp) TGLBoundingBox;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoundingBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLBoundingBox((TGLVertex3*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLBoundingBox((TGLVertex3*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoundingBox* p = NULL;
  struct G__aRyp0 { Double_t a[1][3]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLBoundingBox(G__Ap0->a);
   } else {
     p = new((void*) gvp) TGLBoundingBox(G__Ap0->a);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoundingBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLBoundingBox(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLBoundingBox(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoundingBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLBoundingBox(*(TGLBoundingBox*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLBoundingBox(*(TGLBoundingBox*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLBoundingBox& obj = ((TGLBoundingBox*) G__getstructoffset())->operator=(*(TGLBoundingBox*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Set((TGLVertex3*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][3]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TGLBoundingBox*) G__getstructoffset())->Set(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Set(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->SetEmpty();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->SetAligned(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->SetAligned((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->MergeAligned(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->ExpandAligned(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Transform(*(TGLMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Scale((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Scale((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Translate(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((const TGLBoundingBox*) G__getstructoffset())->operator[]((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((const TGLBoundingBox*) G__getstructoffset())->Vertex((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->XMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->XMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->YMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->YMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->ZMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->ZMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLBoundingBox*) G__getstructoffset())->MinAAVertex();
         pobj = new TGLVertex3(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__GL_102_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLBoundingBox*) G__getstructoffset())->MaxAAVertex();
         pobj = new TGLVertex3(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__GL_102_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLBoundingBox*) G__getstructoffset())->Vertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLBoundingBox*) G__getstructoffset())->NumVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<UInt_t>& obj = ((const TGLBoundingBox*) G__getstructoffset())->FaceVertices((TGLBoundingBox::EFace) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLBoundingBox*) G__getstructoffset())->Center();
         pobj = new TGLVertex3(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__GL_102_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLBoundingBox*) G__getstructoffset())->Extents();
         pobj = new TGLVector3(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__GL_102_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TGLVector3& obj = ((const TGLBoundingBox*) G__getstructoffset())->Axis((UInt_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TGLVector3& obj = ((const TGLBoundingBox*) G__getstructoffset())->Axis((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLBoundingBox*) G__getstructoffset())->IsEmpty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->Volume());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLBoundingBox*) G__getstructoffset())->Diagonal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLBoundingBox*) G__getstructoffset())->PlaneSet(*(TGLPlaneSet_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLPlane* pobj;
         const TGLPlane xobj = ((const TGLBoundingBox*) G__getstructoffset())->GetNearPlane();
         pobj = new TGLPlane(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__GL_102_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLBoundingBox*) G__getstructoffset())->Overlap(*(TGLPlane*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLBoundingBox*) G__getstructoffset())->Overlap(*(TGLBoundingBox*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TGLBoundingBox*) G__getstructoffset())->Draw((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TGLBoundingBox*) G__getstructoffset())->Draw();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLBoundingBox*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLBoundingBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoundingBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLBoundingBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLBoundingBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLBoundingBox*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoundingBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoundingBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBoundingBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoundingBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_102_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBoundingBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLBoundingBox G__TTGLBoundingBox;
static int G__G__GL_102_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLBoundingBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLBoundingBox*) (soff+(sizeof(TGLBoundingBox)*i)))->~G__TTGLBoundingBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLBoundingBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLBoundingBox*) (soff))->~G__TTGLBoundingBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLCamera */
static int G__G__GL_103_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCamera*) G__getstructoffset())->IsOrthographic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCamera*) G__getstructoffset())->IsPerspective());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((const TGLCamera*) G__getstructoffset())->RefModelViewMatrix();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCamera*) G__getstructoffset())->IsCacheDirty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->IncTimeStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLCamera*) G__getstructoffset())->TimeStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetViewport(*(TGLRect*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLRect& obj = ((TGLCamera*) G__getstructoffset())->RefViewport();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLRect& obj = ((const TGLCamera*) G__getstructoffset())->RefViewport();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLCamera*) G__getstructoffset())->Setup(*(TGLBoundingBox*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLCamera*) G__getstructoffset())->Setup(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->Dolly((Int_t) 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__GL_103_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->Zoom((Int_t) 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__GL_103_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->Truck((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->Truck((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->Rotate((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->RotateRad((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TGLCamera*) G__getstructoffset())->Apply(*(TGLBoundingBox*) libp->para[0].ref, (TGLRect*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TGLCamera*) G__getstructoffset())->Apply(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCamera*) G__getstructoffset())->AdjustAndClampVal(
*(Double_t*) G__Doubleref(&libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLCamera*) G__getstructoffset())->AdjustDelta((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetExternalCenter((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->GetExternalCenter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetCenterVec((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetCenterVecWarp((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGLCamera*) G__getstructoffset())->GetCenterVec());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetFixDefCenter((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetFixDefCenterVec((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGLCamera*) G__getstructoffset())->GetFixDefCenterVec());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLCamera*) G__getstructoffset())->GetNearClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLCamera*) G__getstructoffset())->GetFarClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((const TGLCamera*) G__getstructoffset())->GetCamBase();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((const TGLCamera*) G__getstructoffset())->GetCamTrans();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((TGLCamera*) G__getstructoffset())->RefCamBase();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((TGLCamera*) G__getstructoffset())->RefCamTrans();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLCamera*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((const TGLCamera*) G__getstructoffset())->RefLastNoPickProjM();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLCamera*) G__getstructoffset())->EyePoint();
         pobj = new TGLVertex3(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__GL_103_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLCamera*) G__getstructoffset())->EyeDirection();
         pobj = new TGLVector3(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__GL_103_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLCamera*) G__getstructoffset())->FrustumCenter();
         pobj = new TGLVertex3(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__GL_103_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLPlane& obj = ((const TGLCamera*) G__getstructoffset())->FrustumPlane((TGLCamera::EFrustumPlane) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLCamera*) G__getstructoffset())->FrustumOverlap(*(TGLBoundingBox*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLCamera*) G__getstructoffset())->ViewportOverlap(*(TGLBoundingBox*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLRect* pobj;
         const TGLRect xobj = ((const TGLCamera*) G__getstructoffset())->ViewportRect(*(TGLBoundingBox*) libp->para[0].ref, (TGLBoundingBox::EFace) G__int(libp->para[1]));
         pobj = new TGLRect(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__GL_103_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TGLRect* pobj;
         const TGLRect xobj = ((const TGLCamera*) G__getstructoffset())->ViewportRect(*(TGLBoundingBox*) libp->para[0].ref, (const TGLBoundingBox::EFace*) G__int(libp->para[1]));
         pobj = new TGLRect(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TGLRect* pobj;
         const TGLRect xobj = ((const TGLCamera*) G__getstructoffset())->ViewportRect(*(TGLBoundingBox*) libp->para[0].ref);
         pobj = new TGLRect(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLCamera*) G__getstructoffset())->WorldToViewport(*(TGLVertex3*) libp->para[0].ref, (TGLMatrix*) G__int(libp->para[1]));
         pobj = new TGLVertex3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLCamera*) G__getstructoffset())->WorldToViewport(*(TGLVertex3*) libp->para[0].ref);
         pobj = new TGLVertex3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLCamera*) G__getstructoffset())->WorldDeltaToViewport(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
         pobj = new TGLVector3(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__GL_103_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLCamera*) G__getstructoffset())->ViewportToWorld(*(TGLVertex3*) libp->para[0].ref, (TGLMatrix*) G__int(libp->para[1]));
         pobj = new TGLVertex3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLCamera*) G__getstructoffset())->ViewportToWorld(*(TGLVertex3*) libp->para[0].ref);
         pobj = new TGLVertex3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLLine3* pobj;
         const TGLLine3 xobj = ((const TGLCamera*) G__getstructoffset())->ViewportToWorld((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
         pobj = new TGLLine3(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__GL_103_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLLine3* pobj;
         const TGLLine3 xobj = ((const TGLCamera*) G__getstructoffset())->ViewportToWorld(*(TPoint*) libp->para[0].ref);
         pobj = new TGLLine3(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__GL_103_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLCamera*) G__getstructoffset())->ViewportDeltaToWorld(*(TGLVertex3*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGLMatrix*) G__int(libp->para[3]));
         pobj = new TGLVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLCamera*) G__getstructoffset())->ViewportDeltaToWorld(*(TGLVertex3*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
         pobj = new TGLVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<Bool_t,TGLVertex3>* pobj;
         const pair<Bool_t,TGLVertex3> xobj = ((const TGLCamera*) G__getstructoffset())->ViewportPlaneIntersection((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, *(TGLPlane*) libp->para[2].ref);
         pobj = new pair<Bool_t,TGLVertex3>(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__GL_103_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<Bool_t,TGLVertex3>* pobj;
         const pair<Bool_t,TGLVertex3> xobj = ((const TGLCamera*) G__getstructoffset())->ViewportPlaneIntersection(*(TPoint*) libp->para[0].ref, *(TGLPlane*) libp->para[1].ref);
         pobj = new pair<Bool_t,TGLVertex3>(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__GL_103_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLCamera*) G__getstructoffset())->WindowToViewport(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLCamera*) G__getstructoffset())->WindowToViewport(*(TPoint*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLCamera*) G__getstructoffset())->WindowToViewport(*(TGLRect*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLCamera*) G__getstructoffset())->WindowToViewport(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TGLCamera*) G__getstructoffset())->GetVAxisMinAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->SetVAxisMinAngle((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->Configure((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCamera*) G__getstructoffset())->OfInterest(*(TGLBoundingBox*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLCamera*) G__getstructoffset())->UpdateInterest((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->ResetInterest();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLCamera*) G__getstructoffset())->DrawDebugAids();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLCamera::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCamera::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLCamera::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLCamera::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLCamera*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCamera*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCamera::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCamera::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCamera::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_103_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCamera::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLCamera G__TTGLCamera;
static int G__G__GL_103_0_82(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[] (TGLCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLCamera*) (soff+(sizeof(TGLCamera)*i)))->~G__TTGLCamera();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLCamera*) (soff))->~G__TTGLCamera();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLVector3 */
static int G__G__GL_113_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVector3* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVector3[n];
     } else {
       p = new((void*) gvp) TGLVector3[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVector3;
     } else {
       p = new((void*) gvp) TGLVector3;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVector3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVector3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLVector3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLVector3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVector3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVector3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLVector3((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLVector3((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVector3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVector3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLVector3(*(TGLVector3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLVector3(*(TGLVector3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVector3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3& obj = ((TGLVector3*) G__getstructoffset())->operator=(*(TGLVertex3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3& obj = ((TGLVector3*) G__getstructoffset())->operator/=((Double_t) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLVector3*) G__getstructoffset())->operator-();
         pobj = new TGLVector3(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__GL_113_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLVector3*) G__getstructoffset())->Mag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVector3*) G__getstructoffset())->Normalise();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLVector3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVector3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLVector3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLVector3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVector3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVector3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVector3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVector3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_113_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVector3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLVector3 G__TTGLVector3;
static int G__G__GL_113_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLVector3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLVector3*) (soff+(sizeof(TGLVector3)*i)))->~G__TTGLVector3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLVector3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLVector3*) (soff))->~G__TTGLVector3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_113_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVector3* dest = (TGLVector3*) G__getstructoffset();
   *dest = *(TGLVector3*) libp->para[0].ref;
   const TGLVector3& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLVertex3 */
static int G__G__GL_114_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVertex3* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVertex3[n];
     } else {
       p = new((void*) gvp) TGLVertex3[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLVertex3;
     } else {
       p = new((void*) gvp) TGLVertex3;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVertex3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLVertex3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLVertex3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVertex3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLVertex3((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLVertex3((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLVertex3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLVertex3(*(TGLVertex3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLVertex3(*(TGLVertex3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLVertex3*) G__getstructoffset())->operator==(*(TGLVertex3*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((TGLVertex3*) G__getstructoffset())->operator=(*(TGLVertex3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((TGLVertex3*) G__getstructoffset())->operator*=((Double_t) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLVertex3*) G__getstructoffset())->operator-();
         pobj = new TGLVertex3(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__GL_114_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((TGLVertex3*) G__getstructoffset())->operator-=(*(TGLVector3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((TGLVertex3*) G__getstructoffset())->operator+=(*(TGLVector3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Set((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Set(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Shift(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Shift((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Negate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Minimum(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Maximum(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGLVertex3*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((const TGLVertex3*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLVertex3*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGLVertex3*) G__getstructoffset())->X();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLVertex3*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGLVertex3*) G__getstructoffset())->Y();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLVertex3*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGLVertex3*) G__getstructoffset())->Z();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGLVertex3*) G__getstructoffset())->CArr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGLVertex3*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLVertex3*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLVertex3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVertex3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLVertex3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLVertex3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLVertex3*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLVertex3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVertex3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVertex3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLVertex3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_114_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLVertex3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLVertex3 G__TTGLVertex3;
static int G__G__GL_114_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLVertex3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLVertex3*) (soff+(sizeof(TGLVertex3)*i)))->~G__TTGLVertex3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLVertex3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLVertex3*) (soff))->~G__TTGLVertex3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLine3 */
static int G__G__GL_115_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLine3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLLine3(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLLine3(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLine3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLine3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLLine3(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLLine3(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLine3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLine3*) G__getstructoffset())->Set(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLine3*) G__getstructoffset())->Set(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3& obj = ((const TGLLine3*) G__getstructoffset())->Start();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLLine3*) G__getstructoffset())->End();
         pobj = new TGLVertex3(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__GL_115_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3& obj = ((const TGLLine3*) G__getstructoffset())->Vector();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLine3*) G__getstructoffset())->Draw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLine3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLine3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLine3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLine3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLine3*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLine3*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLine3*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLine3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLine3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLine3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLine3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_115_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLine3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_115_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLLine3* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLLine3(*(TGLLine3*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLine3));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLine3 G__TTGLLine3;
static int G__G__GL_115_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLLine3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLine3*) (soff+(sizeof(TGLLine3)*i)))->~G__TTGLLine3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLine3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLine3*) (soff))->~G__TTGLLine3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_115_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLine3* dest = (TGLLine3*) G__getstructoffset();
   *dest = *(TGLLine3*) libp->para[0].ref;
   const TGLLine3& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLRect */
static int G__G__GL_116_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRect* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLRect[n];
     } else {
       p = new((void*) gvp) TGLRect[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLRect;
     } else {
       p = new((void*) gvp) TGLRect;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRect* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLRect(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGLRect(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRect* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLRect(
(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) TGLRect(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->SetCorner((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__GL_116_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->Offset((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__GL_116_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->Expand((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__GL_116_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGLRect*) G__getstructoffset())->CArr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TGLRect*) G__getstructoffset())->CArr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Int_t& obj = ((TGLRect*) G__getstructoffset())->X();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Int_t& obj = ((TGLRect*) G__getstructoffset())->Y();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Width());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Int_t& obj = ((TGLRect*) G__getstructoffset())->Width();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Height());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Int_t& obj = ((TGLRect*) G__getstructoffset())->Height();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->CenterX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->CenterY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Left());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Right());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Top());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Bottom());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Diagonal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Longest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLRect*) G__getstructoffset())->Aspect());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLRect*) G__getstructoffset())->Overlap(*(TGLRect*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLRect::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRect::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLRect::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLRect::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRect*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRect::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLRect::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRect::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_116_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLRect::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_116_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLRect* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLRect(*(TGLRect*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRect));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLRect G__TTGLRect;
static int G__G__GL_116_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLRect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLRect*) (soff+(sizeof(TGLRect)*i)))->~G__TTGLRect();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLRect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLRect*) (soff))->~G__TTGLRect();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_116_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRect* dest = (TGLRect*) G__getstructoffset();
   *dest = *(TGLRect*) libp->para[0].ref;
   const TGLRect& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPlane */
static int G__G__GL_117_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPlane[n];
     } else {
       p = new((void*) gvp) TGLPlane[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPlane;
     } else {
       p = new((void*) gvp) TGLPlane;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPlane(*(TGLPlane*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLPlane(*(TGLPlane*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPlane(
(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) TGLPlane(
(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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPlane((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLPlane((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPlane(*(TGLVector3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLPlane(*(TGLVector3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPlane(
*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TGLPlane(
*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Set(*(TGLPlane*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Set((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]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Set(*(TGLVector3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Set(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Negate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlane*) G__getstructoffset())->A());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlane*) G__getstructoffset())->B());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlane*) G__getstructoffset())->C());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlane*) G__getstructoffset())->D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLPlane*) G__getstructoffset())->Norm();
         pobj = new TGLVector3(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__GL_117_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlane*) G__getstructoffset())->DistanceTo(*(TGLVertex3*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLPlane*) G__getstructoffset())->NearestOn(*(TGLVertex3*) libp->para[0].ref);
         pobj = new TGLVertex3(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__GL_117_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGLPlane*) G__getstructoffset())->CArr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGLPlane*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlane*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlane::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlane::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPlane::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPlane::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPlane*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlane*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlane::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlane::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlane::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_117_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlane::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPlane G__TTGLPlane;
static int G__G__GL_117_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPlane*) (soff+(sizeof(TGLPlane)*i)))->~G__TTGLPlane();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPlane*) (soff))->~G__TTGLPlane();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_117_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlane* dest = (TGLPlane*) G__getstructoffset();
   *dest = *(TGLPlane*) libp->para[0].ref;
   const TGLPlane& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLMatrix */
static int G__G__GL_124_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLMatrix[n];
     } else {
       p = new((void*) gvp) TGLMatrix[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLMatrix;
     } else {
       p = new((void*) gvp) TGLMatrix;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLMatrix(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLMatrix(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLMatrix(*(TGLVertex3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLMatrix(*(TGLVertex3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLMatrix(
*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, *(TGLVector3*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TGLMatrix(
*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, *(TGLVector3*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLMatrix(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLMatrix(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLMatrix((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLMatrix((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLMatrix(*(TGLMatrix*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLMatrix(*(TGLMatrix*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((TGLMatrix*) G__getstructoffset())->operator=(*(TGLMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGLMatrix*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLMatrix*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->MultRight(*(TGLMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->MultLeft(*(TGLMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLMatrix& obj = ((TGLMatrix*) G__getstructoffset())->operator*=(*(TGLMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGLMatrix*) G__getstructoffset())->Set(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, *(TGLVector3*) libp->para[2].ref);
      G__setnull(result7);
      break;
   case 2:
      ((TGLMatrix*) G__getstructoffset())->Set(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->SetIdentity();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->SetTranslation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->SetTranslation(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Translate(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->MoveLF((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Move3LF((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Scale(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Rotate(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->RotateLF((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->RotatePF((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLMatrix*) G__getstructoffset())->TransformVertex(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Transpose3x3();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGLMatrix*) G__getstructoffset())->Invert());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLMatrix*) G__getstructoffset())->GetTranslation();
         pobj = new TGLVector3(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__GL_124_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLMatrix*) G__getstructoffset())->GetScale();
         pobj = new TGLVector3(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__GL_124_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->SetBaseVec((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->SetBaseVec((Int_t) G__int(libp->para[0]), *(TGLVector3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->SetBaseVec((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLMatrix*) G__getstructoffset())->GetBaseVec((Int_t) G__int(libp->para[0]));
         pobj = new TGLVector3(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__GL_124_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLMatrix*) G__getstructoffset())->GetBaseVec((Int_t) G__int(libp->para[0]), *(TGLVector3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLMatrix*) G__getstructoffset())->GetBaseVec((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLMatrix*) G__getstructoffset())->Multiply(*(TGLVector3*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TGLVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLMatrix*) G__getstructoffset())->Multiply(*(TGLVector3*) libp->para[0].ref);
         pobj = new TGLVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLMatrix*) G__getstructoffset())->Rotate(*(TGLVector3*) libp->para[0].ref);
         pobj = new TGLVector3(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__GL_124_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TGLMatrix*) G__getstructoffset())->MultiplyIP(*(TGLVector3*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TGLMatrix*) G__getstructoffset())->MultiplyIP(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLMatrix*) G__getstructoffset())->RotateIP(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGLMatrix*) G__getstructoffset())->CArr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGLMatrix*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLMatrix*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLMatrix::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLMatrix::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLMatrix::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLMatrix::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLMatrix*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLMatrix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLMatrix::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLMatrix::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLMatrix::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_124_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLMatrix::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLMatrix G__TTGLMatrix;
static int G__G__GL_124_0_57(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[] (TGLMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLMatrix*) (soff+(sizeof(TGLMatrix)*i)))->~G__TTGLMatrix();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLMatrix*) (soff))->~G__TTGLMatrix();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLColor */
static int G__G__GL_125_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor[n];
     } else {
       p = new((void*) gvp) TGLColor[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor;
     } else {
       p = new((void*) gvp) TGLColor;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLColor(
(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]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor(
(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) TGLColor(
(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__GLLN_TGLColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLColor(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLColor(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLColor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor((Color_t) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLColor((Color_t) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColor((Color_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLColor((Color_t) 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__GLLN_TGLColor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((TGLColor*) G__getstructoffset())->operator=(*(TGLColor*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TGLColor*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((const TGLColor*) G__getstructoffset())->CArr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TGLColor*) G__getstructoffset())->GetRed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TGLColor*) G__getstructoffset())->GetGreen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TGLColor*) G__getstructoffset())->GetBlue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TGLColor*) G__getstructoffset())->GetAlpha());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLColor*) G__getstructoffset())->GetColorIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TGLColor*) G__getstructoffset())->GetTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetRed((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetGreen((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetBlue((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetAlpha((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLColor*) G__getstructoffset())->SetColor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLColor*) G__getstructoffset())->SetColor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLColor*) G__getstructoffset())->SetColor((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLColor*) G__getstructoffset())->SetColor((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetColor((Color_t) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->SetTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TGLColor*) 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__GL_125_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLColor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLColor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLColor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLColor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLColor*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLColor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLColor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLColor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_125_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLColor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_125_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLColor* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLColor(*(TGLColor*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLColor));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLColor G__TTGLColor;
static int G__G__GL_125_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLColor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLColor*) (soff+(sizeof(TGLColor)*i)))->~G__TTGLColor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLColor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLColor*) (soff))->~G__TTGLColor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLColorSet */
static int G__G__GL_126_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLColorSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColorSet[n];
     } else {
       p = new((void*) gvp) TGLColorSet[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLColorSet;
     } else {
       p = new((void*) gvp) TGLColorSet;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLColorSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColorSet& obj = ((TGLColorSet*) G__getstructoffset())->operator=(*(TGLColorSet*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((TGLColorSet*) G__getstructoffset())->Background();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((TGLColorSet*) G__getstructoffset())->Foreground();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((TGLColorSet*) G__getstructoffset())->Outline();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((TGLColorSet*) G__getstructoffset())->Markup();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((TGLColorSet*) G__getstructoffset())->Selection((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((const TGLColorSet*) G__getstructoffset())->Background();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((const TGLColorSet*) G__getstructoffset())->Foreground();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((const TGLColorSet*) G__getstructoffset())->Outline();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((const TGLColorSet*) G__getstructoffset())->Markup();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColor& obj = ((const TGLColorSet*) G__getstructoffset())->Selection((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColorSet*) G__getstructoffset())->StdDarkBackground();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColorSet*) G__getstructoffset())->StdLightBackground();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLColorSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLColorSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLColorSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLColorSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLColorSet*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColorSet*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColorSet*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLColorSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLColorSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLColorSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLColorSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_126_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLColorSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_126_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLColorSet* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLColorSet(*(TGLColorSet*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLColorSet));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLColorSet G__TTGLColorSet;
static int G__G__GL_126_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[] (TGLColorSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLColorSet*) (soff+(sizeof(TGLColorSet)*i)))->~G__TTGLColorSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLColorSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLColorSet*) (soff))->~G__TTGLColorSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLUtil */
static int G__G__GL_127_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::CheckError((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::GetDrawTesselator3fv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::GetDrawTesselator4fv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::GetDrawTesselator3dv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::GetDrawTesselator4dv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TGLUtil::GetDrawQuality());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::SetDrawQuality((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::ResetDrawQuality();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TGLUtil::GetDefaultDrawQuality());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::SetDefaultDrawQuality((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TGLUtil::LockColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TGLUtil::UnlockColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGLUtil::IsColorLocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color(*(TGLColor*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::ColorAlpha(*(TGLColor*) libp->para[0].ref, (UChar_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::ColorAlpha(*(TGLColor*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      TGLUtil::ColorAlpha((Color_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TGLUtil::ColorAlpha((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      TGLUtil::ColorTransparency((Color_t) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TGLUtil::ColorTransparency((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color3ub((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color4ub((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color3ubv((const UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color4ubv((const UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color3f((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color4f((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color3fv((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Color4fv((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TGLUtil::GetPointSizeScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::SetPointSizeScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TGLUtil::GetLineWidthScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::SetLineWidthScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::PointSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::LineWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TGLUtil::PointSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TGLUtil::LineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::BeginExtendPickRegion((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::EndExtendPickRegion();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      TGLUtil::RenderPolyMarkers(
*(TAttMarker*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      TGLUtil::RenderPolyMarkers(*(TAttMarker*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      TGLUtil::RenderPolyMarkers(*(TAttMarker*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      TGLUtil::RenderPolyMarkers(*(TAttMarker*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      TGLUtil::RenderPoints(*(TAttMarker*) libp->para[0].ref, (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      TGLUtil::RenderPoints(*(TAttMarker*) libp->para[0].ref, (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      TGLUtil::RenderPoints(*(TAttMarker*) libp->para[0].ref, (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TGLUtil::RenderPoints(*(TAttMarker*) libp->para[0].ref, (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      TGLUtil::RenderCrosses(*(TAttMarker*) libp->para[0].ref, (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TGLUtil::RenderCrosses(*(TAttMarker*) libp->para[0].ref, (Float_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      TGLUtil::RenderPolyLine(*(TAttLine*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      TGLUtil::RenderPolyLine(*(TAttLine*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      TGLUtil::RenderPolyLine(*(TAttLine*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      TGLUtil::BeginAttLine(*(TAttLine*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TGLUtil::BeginAttLine(*(TAttLine*) libp->para[0].ref, (Char_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TGLUtil::BeginAttLine(*(TAttLine*) libp->para[0].ref, (Char_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      TGLUtil::EndAttLine((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TGLUtil::EndAttLine((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TGLUtil::EndAttLine();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::SetDrawColors((const UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::DrawSphere(*(TGLVertex3*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (const UChar_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::DrawLine(*(TGLLine3*) libp->para[0].ref, (TGLUtil::ELineHeadShape) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (const UChar_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::DrawLine(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, (TGLUtil::ELineHeadShape) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (const UChar_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::DrawRing(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]), (const UChar_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      TGLUtil::DrawReferenceMarker(*(TGLCamera*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, (Float_t) G__double(libp->para[2]), (const UChar_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TGLUtil::DrawReferenceMarker(*(TGLCamera*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TGLUtil::DrawReferenceMarker(*(TGLCamera*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::DrawSimpleAxes(*(TGLCamera*) libp->para[0].ref, *(TGLBoundingBox*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      TGLUtil::DrawNumber(*(TString*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TGLUtil::DrawNumber(*(TString*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLUtil::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLUtil*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_127_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLUtil G__TTGLUtil;
static int G__G__GL_127_0_65(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[] (TGLUtil*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLUtil*) (soff+(sizeof(TGLUtil)*i)))->~G__TTGLUtil();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLUtil*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLUtil*) (soff))->~G__TTGLUtil();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLUtil::TColorLocker */
static int G__G__GL_128_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLUtil::TColorLocker* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLUtil::TColorLocker[n];
     } else {
       p = new((void*) gvp) TGLUtil::TColorLocker[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLUtil::TColorLocker;
     } else {
       p = new((void*) gvp) TGLUtil::TColorLocker;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::TColorLocker::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TColorLocker::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLUtil::TColorLocker::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::TColorLocker::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLUtil::TColorLocker*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TColorLocker*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TColorLocker*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TColorLocker*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TColorLocker::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::TColorLocker::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TColorLocker::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_128_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::TColorLocker::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_128_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLUtil::TColorLocker* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLUtil::TColorLocker(*(TGLUtil::TColorLocker*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLUtil::TColorLocker G__TTGLUtilcLcLTColorLocker;
static int G__G__GL_128_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLUtil::TColorLocker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLUtil::TColorLocker*) (soff+(sizeof(TGLUtil::TColorLocker)*i)))->~G__TTGLUtilcLcLTColorLocker();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLUtil::TColorLocker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLUtil::TColorLocker*) (soff))->~G__TTGLUtilcLcLTColorLocker();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_128_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLUtil::TColorLocker* dest = (TGLUtil::TColorLocker*) G__getstructoffset();
   *dest = *(TGLUtil::TColorLocker*) libp->para[0].ref;
   const TGLUtil::TColorLocker& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLUtil::TDrawQualityModifier */
static int G__G__GL_129_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLUtil::TDrawQualityModifier* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLUtil::TDrawQualityModifier((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLUtil::TDrawQualityModifier((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::TDrawQualityModifier::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TDrawQualityModifier::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLUtil::TDrawQualityModifier::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::TDrawQualityModifier::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLUtil::TDrawQualityModifier*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TDrawQualityModifier*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TDrawQualityModifier*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TDrawQualityModifier*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TDrawQualityModifier::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::TDrawQualityModifier::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TDrawQualityModifier::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_129_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::TDrawQualityModifier::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_129_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLUtil::TDrawQualityModifier* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLUtil::TDrawQualityModifier(*(TGLUtil::TDrawQualityModifier*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLUtil::TDrawQualityModifier G__TTGLUtilcLcLTDrawQualityModifier;
static int G__G__GL_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLUtil::TDrawQualityModifier*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLUtil::TDrawQualityModifier*) (soff+(sizeof(TGLUtil::TDrawQualityModifier)*i)))->~G__TTGLUtilcLcLTDrawQualityModifier();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLUtil::TDrawQualityModifier*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLUtil::TDrawQualityModifier*) (soff))->~G__TTGLUtilcLcLTDrawQualityModifier();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_129_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLUtil::TDrawQualityModifier* dest = (TGLUtil::TDrawQualityModifier*) G__getstructoffset();
   *dest = *(TGLUtil::TDrawQualityModifier*) libp->para[0].ref;
   const TGLUtil::TDrawQualityModifier& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLUtil::TDrawQualityScaler */
static int G__G__GL_130_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLUtil::TDrawQualityScaler* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLUtil::TDrawQualityScaler((Float_t) G__double(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLUtil::TDrawQualityScaler((Float_t) G__double(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLUtil::TDrawQualityScaler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TDrawQualityScaler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLUtil::TDrawQualityScaler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLUtil::TDrawQualityScaler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLUtil::TDrawQualityScaler*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TDrawQualityScaler*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TDrawQualityScaler*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLUtil::TDrawQualityScaler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TDrawQualityScaler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::TDrawQualityScaler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLUtil::TDrawQualityScaler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_130_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLUtil::TDrawQualityScaler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_130_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLUtil::TDrawQualityScaler* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLUtil::TDrawQualityScaler(*(TGLUtil::TDrawQualityScaler*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLUtil::TDrawQualityScaler G__TTGLUtilcLcLTDrawQualityScaler;
static int G__G__GL_130_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLUtil::TDrawQualityScaler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLUtil::TDrawQualityScaler*) (soff+(sizeof(TGLUtil::TDrawQualityScaler)*i)))->~G__TTGLUtilcLcLTDrawQualityScaler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLUtil::TDrawQualityScaler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLUtil::TDrawQualityScaler*) (soff))->~G__TTGLUtilcLcLTDrawQualityScaler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_130_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLUtil::TDrawQualityScaler* dest = (TGLUtil::TDrawQualityScaler*) G__getstructoffset();
   *dest = *(TGLUtil::TDrawQualityScaler*) libp->para[0].ref;
   const TGLUtil::TDrawQualityScaler& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSelectionBuffer */
static int G__G__GL_138_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectionBuffer* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectionBuffer[n];
     } else {
       p = new((void*) gvp) TGLSelectionBuffer[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectionBuffer;
     } else {
       p = new((void*) gvp) TGLSelectionBuffer;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectionBuffer*) G__getstructoffset())->ReadColorBuffer((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__GL_138_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectionBuffer*) G__getstructoffset())->ReadColorBuffer((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((const TGLSelectionBuffer*) G__getstructoffset())->GetPixelColor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSelectionBuffer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectionBuffer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSelectionBuffer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSelectionBuffer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSelectionBuffer*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectionBuffer*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectionBuffer*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectionBuffer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectionBuffer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectionBuffer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectionBuffer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_138_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectionBuffer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSelectionBuffer G__TTGLSelectionBuffer;
static int G__G__GL_138_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLSelectionBuffer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSelectionBuffer*) (soff+(sizeof(TGLSelectionBuffer)*i)))->~G__TTGLSelectionBuffer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSelectionBuffer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSelectionBuffer*) (soff))->~G__TTGLSelectionBuffer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPlotCoordinates */
static int G__G__GL_143_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlotCoordinates* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPlotCoordinates[n];
     } else {
       p = new((void*) gvp) TGLPlotCoordinates[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPlotCoordinates;
     } else {
       p = new((void*) gvp) TGLPlotCoordinates;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->SetCoordType((EGLCoordType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetCoordType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->SetXLog((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetXLog());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->SetYLog((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetYLog());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->SetZLog((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetZLog());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->ResetModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->Modified());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGLPlotCoordinates*) G__getstructoffset())->SetRanges((TH1*) 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) ((TGLPlotCoordinates*) G__getstructoffset())->SetRanges((TH1*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGLPlotCoordinates*) G__getstructoffset())->SetRanges((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLPlotCoordinates*) G__getstructoffset())->SetRanges((TH2Poly*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLPlotCoordinates*) G__getstructoffset())->SetRanges((TAxis*) G__int(libp->para[0]), (TAxis*) G__int(libp->para[1])
, (TAxis*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetNXBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetNYBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetNZBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::BinRange_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetXBins();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::BinRange_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetYBins();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::BinRange_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetZBins();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetXRange();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetXLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetYRange();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetYLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetZRange();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetZLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetXRangeScaled();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetYRangeScaled();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGLPlotCoordinates*) G__getstructoffset())->GetZRangeScaled();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetXScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetYScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetZScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetFirstXBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetLastXBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetFirstYBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetLastYBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetFirstZBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->GetLastZBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPlotCoordinates*) G__getstructoffset())->GetFactor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlotCoordinates::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotCoordinates::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPlotCoordinates::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPlotCoordinates::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPlotCoordinates*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCoordinates*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotCoordinates::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotCoordinates::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotCoordinates::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_143_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotCoordinates::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPlotCoordinates G__TTGLPlotCoordinates;
static int G__G__GL_143_0_58(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[] (TGLPlotCoordinates*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPlotCoordinates*) (soff+(sizeof(TGLPlotCoordinates)*i)))->~G__TTGLPlotCoordinates();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPlotCoordinates*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPlotCoordinates*) (soff))->~G__TTGLPlotCoordinates();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLQuadric */
static int G__G__GL_144_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLQuadric* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLQuadric[n];
     } else {
       p = new((void*) gvp) TGLQuadric[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLQuadric;
     } else {
       p = new((void*) gvp) TGLQuadric;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLQuadric));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLQuadric*) G__getstructoffset())->Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLQuadric::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLQuadric::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLQuadric::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLQuadric::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLQuadric*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLQuadric*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLQuadric*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLQuadric*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLQuadric::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLQuadric::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLQuadric::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_144_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLQuadric::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLQuadric G__TTGLQuadric;
static int G__G__GL_144_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLQuadric*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLQuadric*) (soff+(sizeof(TGLQuadric)*i)))->~G__TTGLQuadric();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLQuadric*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLQuadric*) (soff))->~G__TTGLQuadric();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Rgl */
static int G__G__GL_146_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::ObjectIDToColor((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) Rgl::ColorToObjectID((const UChar_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawQuadOutline(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref, *(TGLVertex3*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawQuadFilled(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref, *(TGLVertex3*) libp->para[3].ref
, *(TGLVector3*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawQuadFilled((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawSmoothFace(*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref, *(TGLVector3*) libp->para[3].ref
, *(TGLVector3*) libp->para[4].ref, *(TGLVector3*) libp->para[5].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawBoxFront(
(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])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawBoxFrontTextured(
(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])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawCylinder(
(TGLQuadric*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawSphere(
(TGLQuadric*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawError((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])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawAxes(
(Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (TGLVertex3*) G__int(libp->para[2]), (TGLPlotCoordinates*) G__int(libp->para[3])
, (TAxis*) G__int(libp->para[4]), (TAxis*) G__int(libp->para[5])
, (TAxis*) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::SetZLevels((TAxis*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(vector<Double_t>*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawFaceTextured(
*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, *(TGLVector3*) libp->para[6].ref, *(TGLVector3*) libp->para[7].ref
, *(TGLVector3*) libp->para[8].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawFaceTextured(
*(TGLVertex3*) libp->para[0].ref, *(TGLVertex3*) libp->para[1].ref
, *(TGLVertex3*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), *(TGLVector3*) libp->para[7].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::GetColor((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawPalette((TGLPlotCamera*) G__int(libp->para[0]), *(TGLLevelPalette*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawPaletteAxis((TGLPlotCamera*) G__int(libp->para[0]), *(Rgl::Range_t*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<UInt_t>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Double_t>*) libp->para[0].ref, *(vector<Double_t>*) libp->para[1].ref
, *(vector<UInt_t>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Float_t>*) libp->para[0].ref, *(vector<UInt_t>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Double_t>*) libp->para[0].ref, *(vector<UInt_t>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<UInt_t>*) libp->para[2].ref, *(TGLBoxCut*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Double_t>*) libp->para[0].ref, *(vector<Double_t>*) libp->para[1].ref
, *(vector<UInt_t>*) libp->para[2].ref, *(TGLBoxCut*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Float_t>*) libp->para[0].ref, *(vector<UInt_t>*) libp->para[1].ref
, *(TGLBoxCut*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMesh(*(vector<Double_t>*) libp->para[0].ref, *(vector<UInt_t>*) libp->para[1].ref
, *(TGLBoxCut*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMapleMesh(*(vector<Double_t>*) libp->para[0].ref, *(vector<Double_t>*) libp->para[1].ref
, *(vector<UInt_t>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_146_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Rgl::DrawMapleMesh(*(vector<Double_t>*) libp->para[0].ref, *(vector<Double_t>*) libp->para[1].ref
, *(vector<UInt_t>*) libp->para[2].ref, *(TGLBoxCut*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPhysicalShape */
static int G__G__GL_162_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPhysicalShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPhysicalShape(
(UInt_t) G__int(libp->para[0]), *(TGLLogicalShape*) libp->para[1].ref
, *(TGLMatrix*) libp->para[2].ref, (Bool_t) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGLPhysicalShape(
(UInt_t) G__int(libp->para[0]), *(TGLLogicalShape*) libp->para[1].ref
, *(TGLMatrix*) libp->para[2].ref, (Bool_t) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPhysicalShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPhysicalShape(
(UInt_t) G__int(libp->para[0]), *(TGLLogicalShape*) libp->para[1].ref
, (double*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGLPhysicalShape(
(UInt_t) G__int(libp->para[0]), *(TGLLogicalShape*) libp->para[1].ref
, (double*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->AddReference((TGLPShapeRef*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->RemoveReference((TGLPShapeRef*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLPhysicalShape*) G__getstructoffset())->ID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLBoundingBox& obj = ((const TGLPhysicalShape*) G__getstructoffset())->BoundingBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPhysicalShape*) G__getstructoffset())->CalculateShapeLOD(*(TGLRnrCtx*) libp->para[0].ref, *(Float_t*) G__Floatref(&libp->para[1])
, *(Short_t*) G__Shortref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPhysicalShape*) G__getstructoffset())->QuantizeShapeLOD((Short_t) G__int(libp->para[0]), (Short_t) G__int(libp->para[1])
, *(Short_t*) G__Shortref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TGLPhysicalShape*) G__getstructoffset())->SetupGLColors(*(TGLRnrCtx*) libp->para[0].ref, (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TGLPhysicalShape*) G__getstructoffset())->SetupGLColors(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPhysicalShape*) G__getstructoffset())->Draw(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPhysicalShape*) G__getstructoffset())->GetLogical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPhysicalShape*) G__getstructoffset())->GetNextPhysical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPhysicalShape*) G__getstructoffset())->GetManip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetManip((TGLPhysicalShape::EManip) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->Modified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPhysicalShape*) G__getstructoffset())->IsModified());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPhysicalShape*) G__getstructoffset())->IsSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TGLPhysicalShape*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->Select((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TGLPhysicalShape*) G__getstructoffset())->Color());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPhysicalShape*) G__getstructoffset())->IsTransparent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPhysicalShape*) G__getstructoffset())->IsInvisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetColor((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetColorOnFamily((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetDiffuseColor((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetDiffuseColor((const UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetDiffuseColor((Color_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3* pobj;
         const TGLVector3 xobj = ((const TGLPhysicalShape*) G__getstructoffset())->GetScale();
         pobj = new TGLVector3(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__GL_162_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVertex3* pobj;
         const TGLVertex3 xobj = ((const TGLPhysicalShape*) G__getstructoffset())->GetTranslation();
         pobj = new TGLVertex3(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__GL_162_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetTransform(*(TGLMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetTransform((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->SetTranslation(*(TGLVertex3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->Translate(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->Scale(*(TGLVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->Rotate(*(TGLVertex3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPhysicalShape*) G__getstructoffset())->InvokeContextMenu(*(TContextMenu*) libp->para[0].ref, (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__GL_162_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPhysicalShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPhysicalShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPhysicalShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPhysicalShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPhysicalShape*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPhysicalShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPhysicalShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPhysicalShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPhysicalShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_162_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPhysicalShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPhysicalShape G__TTGLPhysicalShape;
static int G__G__GL_162_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPhysicalShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPhysicalShape*) (soff+(sizeof(TGLPhysicalShape)*i)))->~G__TTGLPhysicalShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPhysicalShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPhysicalShape*) (soff))->~G__TTGLPhysicalShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLRnrCtx */
static int G__G__GL_163_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRnrCtx::StyleName((Short_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRnrCtx* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLRnrCtx((TGLViewerBase*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLRnrCtx((TGLViewerBase*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetViewer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLViewerBase& obj = ((TGLRnrCtx*) G__getstructoffset())->RefViewer();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLCamera& obj = ((TGLRnrCtx*) G__getstructoffset())->RefCamera();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetSceneInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLSceneInfo& obj = ((TGLRnrCtx*) G__getstructoffset())->RefSceneInfo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLSceneBase& obj = ((TGLRnrCtx*) G__getstructoffset())->RefScene();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLCamera& obj = ((const TGLRnrCtx*) G__getstructoffset())->RefCamera();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->GetCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetCamera((TGLCamera*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSceneInfo((TGLSceneInfo*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->ViewerLOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetViewerLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->SceneLOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSceneLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->CombiLOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetCombiLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->ShapeLOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetShapeLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLRnrCtx*) G__getstructoffset())->ShapePixSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetShapePixSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->ViewerStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetViewerStyle((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->SceneStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSceneStyle((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLRnrCtx*) G__getstructoffset())->ViewerWFLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetViewerWFLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLRnrCtx*) G__getstructoffset())->SceneWFLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSceneWFLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLRnrCtx*) G__getstructoffset())->ViewerOLLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetViewerOLLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLRnrCtx*) G__getstructoffset())->SceneOLLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSceneOLLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->ViewerClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetViewerClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->SceneClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSceneClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->Clip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->HasClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLRnrCtx*) G__getstructoffset())->DrawPass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetDrawPass((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->IsDrawPassFilled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->IsDrawPassOutlineLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLRnrCtx*) G__getstructoffset())->RenderTimeOut());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetRenderTimeOut((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->StartStopwatch();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->StopStopwatch();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->IsStopwatchRunning());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLRnrCtx*) G__getstructoffset())->HasStopwatchTimedOut());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->Highlight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetHighlight((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->HighlightOutline());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetHighlightOutline((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->Selection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSelection((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->SecSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetSecSelection((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetPickRectangle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLRnrCtx*) G__getstructoffset())->GetPickRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->GetSelectBuffer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGLRnrCtx*) G__getstructoffset())->BeginSelection((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLRnrCtx*) G__getstructoffset())->BeginSelection((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->EndSelection((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->PushColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColorSet& obj = ((TGLRnrCtx*) G__getstructoffset())->ColorSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->PopColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->ChangeBaseColorSet((TGLColorSet*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetBaseColorSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->ColorOrForeground((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLRnrCtx*) G__getstructoffset())->GetRenderScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetRenderScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLRnrCtx*) G__getstructoffset())->GetEventKeySym());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetEventKeySym((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->IsDLCaptureOpen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->OpenDLCapture();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->CloseDLCapture();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->GetGLCtxIdentity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetGLCtxIdentity((TGLContextIdentity*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->RegisterFont((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(TGLFont*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->RegisterFont((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(TGLFont*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->RegisterFontNoScale((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(TGLFont*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->RegisterFontNoScale((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(TGLFont*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->ReleaseFont(*(TGLFont*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLRnrCtx*) G__getstructoffset())->GetGluQuadric());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->SetGrabImage((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLRnrCtx*) G__getstructoffset())->GetGrabImage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->ProjectionMatrixPushIdentity();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->ProjectionMatrixPop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLRnrCtx::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRnrCtx::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLRnrCtx::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLRnrCtx::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLRnrCtx*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRnrCtx*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRnrCtx::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLRnrCtx::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRnrCtx::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_163_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLRnrCtx::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLRnrCtx G__TTGLRnrCtx;
static int G__G__GL_163_0_106(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[] (TGLRnrCtx*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLRnrCtx*) (soff+(sizeof(TGLRnrCtx)*i)))->~G__TTGLRnrCtx();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLRnrCtx*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLRnrCtx*) (soff))->~G__TTGLRnrCtx();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSelectRecord */
static int G__G__GL_164_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectRecord* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectRecord[n];
     } else {
       p = new((void*) gvp) TGLSelectRecord[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectRecord;
     } else {
       p = new((void*) gvp) TGLSelectRecord;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectRecord* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSelectRecord((UInt_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLSelectRecord((UInt_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectRecord* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSelectRecord(*(TGLSelectRecord*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLSelectRecord(*(TGLSelectRecord*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLSelectRecord& obj = ((TGLSelectRecord*) G__getstructoffset())->operator=(*(TGLSelectRecord*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetTransparent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetSceneInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetPhysShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetSpecific());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetMultiple());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetHighlight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLSelectRecord*) G__getstructoffset())->GetSecSelResult());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetTransparent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetSceneInfo((TGLSceneInfo*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetPhysShape((TGLPhysicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetSpecific((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetMultiple((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetHighlight((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->SetSecSelResult((TGLSelectRecord::ESecSelResult) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGLSelectRecord::AreSameSelectionWise(*(TGLSelectRecord*) libp->para[0].ref, *(TGLSelectRecord*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSelectRecord::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectRecord::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSelectRecord::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSelectRecord::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecord*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectRecord::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectRecord::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectRecord::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_164_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectRecord::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSelectRecord G__TTGLSelectRecord;
static int G__G__GL_164_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLSelectRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSelectRecord*) (soff+(sizeof(TGLSelectRecord)*i)))->~G__TTGLSelectRecord();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSelectRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSelectRecord*) (soff))->~G__TTGLSelectRecord();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLViewer */
static int G__G__GL_165_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLViewer(
(TVirtualPad*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGLViewer(
(TVirtualPad*) 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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLViewer((TVirtualPad*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLViewer((TVirtualPad*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLViewer*) G__getstructoffset())->GetGLWidget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->CreateGLWidget();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->DestroyGLWidget();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLViewer*) G__getstructoffset())->GetDev());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetSmartRefresh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetSmartRefresh((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColorSet& obj = ((TGLViewer*) G__getstructoffset())->RefDarkColorSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColorSet& obj = ((TGLViewer*) G__getstructoffset())->RefLightColorSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColorSet& obj = ((TGLViewer*) G__getstructoffset())->ColorSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->UseDarkColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->UseLightColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SwitchColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->UseDefaultColorSet((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->IsUsingDefaultColorSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->IsColorSetDark());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetClearColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLColorSet& obj = TGLViewer::GetDefaultColorSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLViewer::UseDefaultColorSetForNewViewers((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGLViewer::IsUsingDefaultColorSetForNewViewers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLRect& obj = ((const TGLViewer*) G__getstructoffset())->RefViewport();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLViewer*) G__getstructoffset())->ViewportDiagonal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetPointScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetLineScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetPointScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetLineScale((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetSmoothPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetSmoothLines());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetSmoothPoints((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetSmoothLines((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetLightSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetClipSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetClipAutoUpdate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetClipAutoUpdate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLCamera& obj = ((const TGLViewer*) G__getstructoffset())->CurrentCamera();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLCamera& obj = ((TGLViewer*) G__getstructoffset())->RefCamera((TGLViewer::ECameraType) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetCurrentCamera((TGLViewer::ECameraType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetOrthoCamera((TGLViewer::ECameraType) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetPerspectiveCamera((TGLViewer::ECameraType) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLViewer*) G__getstructoffset())->GetGuideState(*(Int_t*) G__Intref(&libp->para[0]), *(Bool_t*) G__Boolref(&libp->para[1])
, *(Bool_t*) G__Boolref(&libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetGuideState((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetDrawCameraCenter((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->GetDrawCameraCenter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->PickCameraCenter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->PickAnnotate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetCameraOverlay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetCameraOverlay((TGLCameraOverlay*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLViewer*) G__getstructoffset())->GetAutoRotator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetAutoRotator((TGLAutoRotator*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetStereo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetStereoZeroParallax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetStereoEyeOffsetFac());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetStereoFrustumAsymFac());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetStereo((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetStereoZeroParallax((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetStereoEyeOffsetFac((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetStereoFrustumAsymFac((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLViewer*) G__getstructoffset())->GetPushAction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLViewer*) G__getstructoffset())->GetDragAction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetMaxSceneDrawTimeHQ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetMaxSceneDrawTimeLQ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetMaxSceneDrawTimeHQ((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetMaxSceneDrawTimeLQ((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLViewer*) G__getstructoffset())->RequestDraw((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLViewer*) G__getstructoffset())->RequestDraw();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLViewer*) G__getstructoffset())->DoDraw((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLViewer*) G__getstructoffset())->DoDraw();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->DoDrawMono((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->DoDrawStereo((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->DrawGuides();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->DrawDebugInfo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->RequestSelect((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->DoSelect((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->RequestSecondarySelect((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->DoSecondarySelect((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->ApplySelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->RequestOverlaySelect((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->DoOverlaySelect((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePicture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePicture(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureUsingBB(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureUsingFBO(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureUsingFBO(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureWidth(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureWidth(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureHeight(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureHeight(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureScale(*(TString*) libp->para[0].ref, (Float_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TGLViewer*) G__getstructoffset())->SavePictureScale(*(TString*) libp->para[0].ref, (Float_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGLViewer*) G__getstructoffset())->GetPictureFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetPictureFileName(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewer*) G__getstructoffset())->GetFader());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetFader((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGLViewer*) G__getstructoffset())->AutoFade((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLViewer*) G__getstructoffset())->AutoFade((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLViewer*) G__getstructoffset())->AutoFade((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLViewer*) G__getstructoffset())->UpdateScene((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLViewer*) G__getstructoffset())->UpdateScene();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetIgnoreSizesOnUpdate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetIgnoreSizesOnUpdate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->ResetCurrentCamera();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewer*) G__getstructoffset())->GetResetCamerasOnUpdate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetResetCamerasOnUpdate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->PostSceneBuildSetup((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->Activated();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->MouseIdle((TGLPhysicalShape*) 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__GL_165_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->MouseOver((TGLPhysicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->MouseOver((TGLPhysicalShape*) 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__GL_165_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->MouseOver((TObject*) 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__GL_165_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->ReMouseOver((TObject*) 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__GL_165_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->UnMouseOver((TObject*) 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__GL_165_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->Clicked((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->Clicked((TObject*) 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__GL_165_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->ReClicked((TObject*) 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__GL_165_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->UnClicked((TObject*) 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__GL_165_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->DoubleClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetEventHandler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetEventHandler((TGEventHandler*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetGedEditor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SetGedEditor((TGedEditor*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->SelectionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->OverlayDragFinished();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLViewer*) G__getstructoffset())->RefreshPadEditor((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLViewer*) G__getstructoffset())->RefreshPadEditor();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLSelectRecord& obj = ((TGLViewer*) G__getstructoffset())->GetSelRec();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLOvlSelectRecord& obj = ((TGLViewer*) G__getstructoffset())->GetOvlSelRec();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewer*) G__getstructoffset())->GetCurrentOvlElm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->ClearCurrentOvlElm();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLViewer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLViewer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLViewer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLViewer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_165_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLViewer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLViewer G__TTGLViewer;
static int G__G__GL_165_0_165(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[] (TGLViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLViewer*) (soff+(sizeof(TGLViewer)*i)))->~G__TTGLViewer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLViewer*) (soff))->~G__TTGLViewer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSceneBase */
static int G__G__GL_166_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->AddViewer((TGLViewerBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->RemoveViewer((TGLViewerBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->TagViewersChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGLSceneBase*) G__getstructoffset())->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGLSceneBase*) G__getstructoffset())->GetTitle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetNameTitle((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLSceneBase*) G__getstructoffset())->CreateSceneInfo((TGLViewerBase*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->RebuildSceneInfo(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->UpdateSceneInfo(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->LodifySceneInfo(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->PreDraw(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->PreRender(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->Render(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->RenderOpaque(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->RenderTransp(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->RenderSelOpaque(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->RenderSelTransp(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->PostRender(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->PostDraw(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneBase*) G__getstructoffset())->FindLogical((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLSceneBase*) G__getstructoffset())->ResolveSelectRecord(*(TGLSelectRecord*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSceneBase*) G__getstructoffset())->GetTimeStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->IncTimeStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSceneBase*) G__getstructoffset())->GetMinorStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->IncMinorStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLSceneBase*) G__getstructoffset())->LOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLSceneBase*) G__getstructoffset())->Style());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetStyle((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneBase*) G__getstructoffset())->Clip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneBase*) G__getstructoffset())->GetSelectable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetSelectable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneBase*) G__getstructoffset())->GetAutoDestruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->SetAutoDestruct((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLSceneBase*) G__getstructoffset())->CalcBoundingBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->InvalidateBoundingBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLBoundingBox& obj = ((const TGLSceneBase*) G__getstructoffset())->BoundingBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSceneBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSceneBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSceneBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSceneBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSceneBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSceneBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSceneBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_166_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSceneBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSceneBase G__TTGLSceneBase;
static int G__G__GL_166_0_57(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[] (TGLSceneBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSceneBase*) (soff+(sizeof(TGLSceneBase)*i)))->~G__TTGLSceneBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSceneBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSceneBase*) (soff))->~G__TTGLSceneBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLScene */
static int G__G__GL_167_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLScene* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLScene[n];
     } else {
       p = new((void*) gvp) TGLScene[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLScene;
     } else {
       p = new((void*) gvp) TGLScene;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->RenderAllPasses(*(TGLRnrCtx*) libp->para[0].ref, *(TGLScene::DrawElementPtrVec_t*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLScene*) G__getstructoffset())->RenderElements(*(TGLRnrCtx*) libp->para[0].ref, *(TGLScene::DrawElementPtrVec_t*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]), (TGLPlaneSet_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLScene*) G__getstructoffset())->RenderElements(*(TGLRnrCtx*) libp->para[0].ref, *(TGLScene::DrawElementPtrVec_t*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->AdoptLogical(*(TGLLogicalShape*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGLScene*) G__getstructoffset())->DestroyLogical((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGLScene*) G__getstructoffset())->DestroyLogical((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLScene*) G__getstructoffset())->DestroyLogicals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->AdoptPhysical(*(TGLPhysicalShape*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLScene*) G__getstructoffset())->DestroyPhysical((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGLScene*) G__getstructoffset())->DestroyPhysicals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLScene*) G__getstructoffset())->FindPhysical((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TGLScene*) G__getstructoffset())->GetMaxPhysicalID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLScene*) G__getstructoffset())->BeginUpdate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGLScene*) G__getstructoffset())->EndUpdate((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLScene*) G__getstructoffset())->EndUpdate((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLScene*) G__getstructoffset())->EndUpdate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLScene*) G__getstructoffset())->EndUpdate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->UpdateLogical((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->UpdatePhysical((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UChar_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLScene*) G__getstructoffset())->UpdatePhysical((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Color_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLScene*) G__getstructoffset())->UpdatePhysical((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Color_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLScene*) G__getstructoffset())->UpdatePhysical((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->UpdatePhysioLogical((TObject*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (UChar_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->UpdatePhysioLogical((TObject*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Color_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLScene::LogicalShapeMap_t& obj = ((TGLScene*) G__getstructoffset())->RefLogicalShapes();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TGLScene*) G__getstructoffset())->BeginSmartRefresh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->EndSmartRefresh();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLScene*) G__getstructoffset())->FindLogicalSmartRefresh((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLScene*) G__getstructoffset())->GetGLCtxIdentity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLScene*) G__getstructoffset())->SizeOfScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLScene*) G__getstructoffset())->DumpMapSizes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      TGLScene::RGBAFromColorIdx((Float_t*) G__int(libp->para[0]), (Color_t) G__int(libp->para[1])
, (Char_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TGLScene::RGBAFromColorIdx((Float_t*) G__int(libp->para[0]), (Color_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGLScene::IsOutside(*(TGLBoundingBox*) libp->para[0].ref, *(TGLPlaneSet_t*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLScene::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScene::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLScene::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLScene::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScene::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLScene::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScene::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_167_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLScene::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLScene G__TTGLScene;
static int G__G__GL_167_0_59(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[] (TGLScene*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLScene*) (soff+(sizeof(TGLScene)*i)))->~G__TTGLScene();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLScene*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLScene*) (soff))->~G__TTGLScene();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLogicalShape */
static int G__G__GL_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLLogicalShape*) G__getstructoffset())->Ref());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLogicalShape*) G__getstructoffset())->AddRef((TGLPhysicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLogicalShape*) G__getstructoffset())->SubRef((TGLPhysicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLogicalShape*) G__getstructoffset())->StrongRef((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->DestroyPhysicals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TGLLogicalShape*) G__getstructoffset())->UnrefFirstPhysical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLogicalShape*) G__getstructoffset())->GetFirstPhysical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLogicalShape*) G__getstructoffset())->ID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLogicalShape*) G__getstructoffset())->GetExternal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLogicalShape*) G__getstructoffset())->GetScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLBoundingBox& obj = ((const TGLLogicalShape*) G__getstructoffset())->BoundingBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->UpdateBoundingBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->UpdateBoundingBoxesOfPhysicals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLLogicalShape*) G__getstructoffset())->SetDLCache((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLogicalShape*) G__getstructoffset())->ShouldDLCache(*(TGLRnrCtx*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLLogicalShape*) G__getstructoffset())->DLOffset((Short_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->DLCacheClear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->DLCacheDrop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->DLCachePurge();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLLogicalShape*) G__getstructoffset())->SupportedLODAxes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLLogicalShape*) G__getstructoffset())->QuantizeShapeLOD((Short_t) G__int(libp->para[0]), (Short_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLogicalShape*) G__getstructoffset())->Draw(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLogicalShape*) G__getstructoffset())->DirectDraw(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TGLLogicalShape*) G__getstructoffset())->DrawHighlight(*(TGLRnrCtx*) libp->para[0].ref, (TGLPhysicalShape*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TGLLogicalShape*) G__getstructoffset())->DrawHighlight(*(TGLRnrCtx*) libp->para[0].ref, (TGLPhysicalShape*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLogicalShape*) G__getstructoffset())->IgnoreSizeForOfInterest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLogicalShape*) G__getstructoffset())->KeepDuringSmartRefresh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLogicalShape*) G__getstructoffset())->SupportsSecondarySelect());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLogicalShape*) G__getstructoffset())->AlwaysSecondarySelect());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->ProcessSelection(*(TGLRnrCtx*) libp->para[0].ref, *(TGLSelectRecord*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLLogicalShape*) G__getstructoffset())->InvokeContextMenu(*(TContextMenu*) libp->para[0].ref, (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__GL_168_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLogicalShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLogicalShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLogicalShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLogicalShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLogicalShape*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLogicalShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLogicalShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLogicalShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLogicalShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_168_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLogicalShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLogicalShape G__TTGLLogicalShape;
static int G__G__GL_168_0_49(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[] (TGLLogicalShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLogicalShape*) (soff+(sizeof(TGLLogicalShape)*i)))->~G__TTGLLogicalShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLogicalShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLogicalShape*) (soff))->~G__TTGLLogicalShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLObject */
static int G__G__GL_205_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TGLObject*) G__getstructoffset())->SetModel((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TGLObject*) G__getstructoffset())->SetModel((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLObject*) G__getstructoffset())->SetBBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLObject::GetGLRenderer((TClass*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_205_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLObject G__TTGLObject;
static int G__G__GL_205_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLObject*) (soff+(sizeof(TGLObject)*i)))->~G__TTGLObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLObject*) (soff))->~G__TTGLObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLManip */
static int G__G__GL_225_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLManip*) G__getstructoffset())->GetSelectedWidget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManip*) G__getstructoffset())->SetSelectedWidget((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLManip*) G__getstructoffset())->GetActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManip*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManip*) G__getstructoffset())->Attach((TGLPhysicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLManip*) G__getstructoffset())->GetAttached());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLManip*) G__getstructoffset())->Draw(*(TGLCamera*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManip*) G__getstructoffset())->HandleButton(*(Event_t*) libp->para[0].ref, *(TGLCamera*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLManip*) G__getstructoffset())->HandleMotion(*(Event_t*) libp->para[0].ref, *(TGLCamera*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLManip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLManip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLManip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLManip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_225_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLManip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLManip G__TTGLManip;
static int G__G__GL_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLManip*) (soff+(sizeof(TGLManip)*i)))->~G__TTGLManip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLManip*) (soff))->~G__TTGLManip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLContext */
static int G__G__GL_229_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLContext* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLContext(
(TGLWidget*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (TGLContext*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLContext(
(TGLWidget*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (TGLContext*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLContext((TGLWidget*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLContext((TGLWidget*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLContext((TGLWidget*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLContext((TGLWidget*) 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__GLLN_TGLContext));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLContext*) G__getstructoffset())->GetIdentity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLContext*) G__getstructoffset())->MakeCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLContext*) G__getstructoffset())->ClearCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContext*) G__getstructoffset())->SwapBuffers();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContext*) G__getstructoffset())->SetContext((TGLWidget*) G__int(libp->para[0]), (TGLContext*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContext*) G__getstructoffset())->Release();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLContext*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLContext::GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLContext::GlewInit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLContext::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLContext::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLContext::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLContext::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLContext*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContext*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContext*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContext*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLContext::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLContext::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLContext::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_229_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLContext::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLContext G__TTGLContext;
static int G__G__GL_229_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLContext*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLContext*) (soff+(sizeof(TGLContext)*i)))->~G__TTGLContext();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLContext*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLContext*) (soff))->~G__TTGLContext();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLFormat */
static int G__G__GL_230_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFormat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFormat[n];
     } else {
       p = new((void*) gvp) TGLFormat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFormat;
     } else {
       p = new((void*) gvp) TGLFormat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFormat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFormat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLFormat((TGLFormat::EFormatOptions) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLFormat((TGLFormat::EFormatOptions) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFormat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->operator==(*(TGLFormat*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->operator!=(*(TGLFormat*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFormat*) G__getstructoffset())->GetDepthSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->SetDepthSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->HasDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFormat*) G__getstructoffset())->GetStencilSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->SetStencilSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->HasStencil());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFormat*) G__getstructoffset())->GetAccumSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->SetAccumSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->HasAccumBuffer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->IsDoubleBuffered());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->SetDoubleBuffered((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->IsStereo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->SetStereo((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFormat*) G__getstructoffset())->GetSamples());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->SetSamples((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFormat*) G__getstructoffset())->HasMultiSampling());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFormat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFormat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLFormat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFormat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFormat*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFormat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFormat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFormat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFormat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_230_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFormat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_230_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLFormat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLFormat(*(TGLFormat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFormat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLFormat G__TTGLFormat;
static int G__G__GL_230_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLFormat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLFormat*) (soff+(sizeof(TGLFormat)*i)))->~G__TTGLFormat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLFormat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLFormat*) (soff))->~G__TTGLFormat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_230_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFormat* dest = (TGLFormat*) G__getstructoffset();
   *dest = *(TGLFormat*) libp->para[0].ref;
   const TGLFormat& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPlotBox */
static int G__G__GL_233_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlotBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPlotBox(
(Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLPlotBox(
(Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_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__GLLN_TGLPlotBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlotBox*) G__getstructoffset())->DrawBox((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, *(vector<Double_t>*) libp->para[2].ref, (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotBox*) G__getstructoffset())->SetPlotBox(*(Rgl::Range_t*) libp->para[0].ref, *(Rgl::Range_t*) libp->para[1].ref
, *(Rgl::Range_t*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotBox*) G__getstructoffset())->SetPlotBox(*(Rgl::Range_t*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, *(Rgl::Range_t*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, *(Rgl::Range_t*) libp->para[4].ref, (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotBox*) G__getstructoffset())->SetFrameColor((TColor*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotBox*) G__getstructoffset())->FindFrontPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotBox*) G__getstructoffset())->GetFrontPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPlotBox*) G__getstructoffset())->Get3DBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPlotBox*) G__getstructoffset())->Get2DBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlotBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPlotBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPlotBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPlotBox*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotBox*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotBox*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_233_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_233_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLPlotBox* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLPlotBox(*(TGLPlotBox*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPlotBox G__TTGLPlotBox;
static int G__G__GL_233_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPlotBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPlotBox*) (soff+(sizeof(TGLPlotBox)*i)))->~G__TTGLPlotBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPlotBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPlotBox*) (soff))->~G__TTGLPlotBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPlotCamera */
static int G__G__GL_234_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPlotCamera* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPlotCamera[n];
     } else {
       p = new((void*) gvp) TGLPlotCamera[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPlotCamera;
     } else {
       p = new((void*) gvp) TGLPlotCamera;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->SetViewport(*(TGLRect*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->SetViewVolume((TGLVertex3*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->StartRotation((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__GL_234_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->RotateCamera((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__GL_234_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->StartPan((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__GL_234_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->Pan((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__GL_234_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->ZoomIn();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->ZoomOut();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlotCamera*) G__getstructoffset())->SetCamera();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlotCamera*) G__getstructoffset())->Apply((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPlotCamera*) G__getstructoffset())->ViewportChanged());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCamera*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCamera*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCamera*) G__getstructoffset())->GetWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLPlotCamera*) G__getstructoffset())->GetHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlotCamera::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotCamera::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPlotCamera::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPlotCamera::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPlotCamera*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotCamera*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotCamera::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotCamera::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotCamera::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_234_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotCamera::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPlotCamera G__TTGLPlotCamera;
static int G__G__GL_234_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPlotCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPlotCamera*) (soff+(sizeof(TGLPlotCamera)*i)))->~G__TTGLPlotCamera();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPlotCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPlotCamera*) (soff))->~G__TTGLPlotCamera();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGL5DDataSet */
static int G__G__GL_235_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGL5DDataSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGL5DDataSet((TTree*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGL5DDataSet((TTree*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGL5DDataSet*) G__getstructoffset())->GetRealPainter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSet*) G__getstructoffset())->SelectPoints((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGL5DDataSet*) G__getstructoffset())->SelectedSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGL5DDataSet*) G__getstructoffset())->V1((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGL5DDataSet*) G__getstructoffset())->V2((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGL5DDataSet*) G__getstructoffset())->V3((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGL5DDataSet*) G__getstructoffset())->GetXAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGL5DDataSet*) G__getstructoffset())->GetYAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGL5DDataSet*) G__getstructoffset())->GetZAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGL5DDataSet*) G__getstructoffset())->GetXRange();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGL5DDataSet*) G__getstructoffset())->GetYRange();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGL5DDataSet*) G__getstructoffset())->GetZRange();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t& obj = ((const TGL5DDataSet*) G__getstructoffset())->GetV4Range();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGL5DDataSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGL5DDataSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGL5DDataSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGL5DDataSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGL5DDataSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGL5DDataSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGL5DDataSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_235_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGL5DDataSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGL5DDataSet G__TTGL5DDataSet;
static int G__G__GL_235_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGL5DDataSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGL5DDataSet*) (soff+(sizeof(TGL5DDataSet)*i)))->~G__TTGL5DDataSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGL5DDataSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGL5DDataSet*) (soff))->~G__TTGL5DDataSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLBoxCut */
static int G__G__GL_239_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoxCut* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLBoxCut((TGLPlotBox*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLBoxCut((TGLPlotBox*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->TurnOnOff();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLBoxCut*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->ResetBoxGeometry();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->SetFactor((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLBoxCut*) G__getstructoffset())->DrawBox((Bool_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__GL_239_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->StartMovement((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__GL_239_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->MoveBox((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLBoxCut*) G__getstructoffset())->IsInCut((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])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t* pobj;
         const Rgl::Range_t xobj = ((const TGLBoxCut*) G__getstructoffset())->GetXRange();
         pobj = new Rgl::Range_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__GL_239_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t* pobj;
         const Rgl::Range_t xobj = ((const TGLBoxCut*) G__getstructoffset())->GetYRange();
         pobj = new Rgl::Range_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__GL_239_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t* pobj;
         const Rgl::Range_t xobj = ((const TGLBoxCut*) G__getstructoffset())->GetZRange();
         pobj = new Rgl::Range_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__GL_239_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLBoxCut::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoxCut::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLBoxCut::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLBoxCut::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLBoxCut*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxCut*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoxCut::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBoxCut::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoxCut::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_239_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBoxCut::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_239_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLBoxCut* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLBoxCut(*(TGLBoxCut*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLBoxCut G__TTGLBoxCut;
static int G__G__GL_239_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[] (TGLBoxCut*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLBoxCut*) (soff+(sizeof(TGLBoxCut)*i)))->~G__TTGLBoxCut();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLBoxCut*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLBoxCut*) (soff))->~G__TTGLBoxCut();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLTH3Slice */
static int G__G__GL_240_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTH3Slice* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLTH3Slice(
*(TString*) libp->para[0].ref, (TH3*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]), (TGLPlotBox*) G__int(libp->para[3])
, (TGLTH3Slice::ESliceAxis) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGLTH3Slice(
*(TString*) libp->para[0].ref, (TH3*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]), (TGLPlotBox*) G__int(libp->para[3])
, (TGLTH3Slice::ESliceAxis) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTH3Slice* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLTH3Slice(
*(TString*) libp->para[0].ref, (TH3*) G__int(libp->para[1])
, (TF3*) G__int(libp->para[2]), (TGLPlotCoordinates*) G__int(libp->para[3])
, (TGLPlotBox*) G__int(libp->para[4]), (TGLTH3Slice::ESliceAxis) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TGLTH3Slice(
*(TString*) libp->para[0].ref, (TH3*) G__int(libp->para[1])
, (TF3*) G__int(libp->para[2]), (TGLPlotCoordinates*) G__int(libp->para[3])
, (TGLPlotBox*) G__int(libp->para[4]), (TGLTH3Slice::ESliceAxis) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLTH3Slice*) G__getstructoffset())->DrawSlice((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLTH3Slice*) G__getstructoffset())->SetSliceWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLTH3Slice*) G__getstructoffset())->SetSliceWidth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLTH3Slice*) G__getstructoffset())->SetMinMax(*(Rgl::Range_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLLevelPalette& obj = ((const TGLTH3Slice*) G__getstructoffset())->GetPalette();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLTH3Slice::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3Slice::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLTH3Slice::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLTH3Slice::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLTH3Slice*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3Slice::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTH3Slice::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3Slice::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_240_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTH3Slice::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLTH3Slice G__TTGLTH3Slice;
static int G__G__GL_240_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[] (TGLTH3Slice*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLTH3Slice*) (soff+(sizeof(TGLTH3Slice)*i)))->~G__TTGLTH3Slice();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLTH3Slice*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLTH3Slice*) (soff))->~G__TTGLTH3Slice();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPlotPainter */
static int G__G__GL_243_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLPlotBox& obj = ((const TGLPlotPainter*) G__getstructoffset())->RefBackBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlotPainter*) G__getstructoffset())->InitGL();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlotPainter*) G__getstructoffset())->DeInitGL();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPlotPainter*) G__getstructoffset())->DrawPlot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLPlotPainter*) G__getstructoffset())->InitGeometry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->StartPan((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__GL_243_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->AddOption(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->ProcessEvent((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->SetPadColor((TColor*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->SetFrameColor((TColor*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->InvalidateSelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLPlotPainter*) G__getstructoffset())->CutAxisSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlotPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPlotPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPlotPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlotPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlotPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_243_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlotPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPlotPainter G__TTGLPlotPainter;
static int G__G__GL_243_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPlotPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPlotPainter*) (soff+(sizeof(TGLPlotPainter)*i)))->~G__TTGLPlotPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPlotPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPlotPainter*) (soff))->~G__TTGLPlotPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPlot3D */
static int G__G__GL_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlot3D::CreatePlot((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (TVirtualPad*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlot3D::CreatePlot((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Bool_t) 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__GL_249_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPlot3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlot3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPlot3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPlot3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPlot3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlot3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlot3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPlot3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_249_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPlot3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPlot3D G__TTGLPlot3D;
static int G__G__GL_249_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPlot3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPlot3D*) (soff+(sizeof(TGLPlot3D)*i)))->~G__TTGLPlot3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPlot3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPlot3D*) (soff))->~G__TTGLPlot3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TF2GL */
static int G__G__GL_252_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2GL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2GL[n];
     } else {
       p = new((void*) gvp) TF2GL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2GL;
     } else {
       p = new((void*) gvp) TF2GL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TF2GL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TF2GL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF2GL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TF2GL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF2GL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF2GL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF2GL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF2GL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF2GL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_252_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF2GL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TF2GL G__TTF2GL;
static int G__G__GL_252_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TF2GL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TF2GL*) (soff+(sizeof(TF2GL)*i)))->~G__TTF2GL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TF2GL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TF2GL*) (soff))->~G__TTF2GL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGL5DDataSetEditor */
static int G__G__GL_351_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGL5DDataSetEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGL5DDataSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGL5DDataSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGL5DDataSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGL5DDataSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGL5DDataSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGL5DDataSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGL5DDataSetEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGL5DDataSetEditor((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 TGL5DDataSetEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGL5DDataSetEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGL5DDataSetEditor[n];
       } else {
         p = new((void*) gvp) TGL5DDataSetEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGL5DDataSetEditor;
       } else {
         p = new((void*) gvp) TGL5DDataSetEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->GridParametersChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->XSliderChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->YSliderChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ZSliderChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->XSliderSetMin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->XSliderSetMax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->YSliderSetMin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->YSliderSetMax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ZSliderSetMin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ZSliderSetMax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->RollbackGridParameters();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ApplyGridParameters();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->HighlightClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->SurfaceSelected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->VisibleClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ColorChanged((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->AlphaChanged((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->RemoveSurface();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->AddNewSurface();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ApplyAlpha();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->ApplyPlanes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->BoxCutToggled();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->AlphaChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->NContoursChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGL5DDataSetEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGL5DDataSetEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGL5DDataSetEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGL5DDataSetEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGL5DDataSetEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGL5DDataSetEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGL5DDataSetEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGL5DDataSetEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_351_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGL5DDataSetEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGL5DDataSetEditor G__TTGL5DDataSetEditor;
static int G__G__GL_351_0_52(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[] (TGL5DDataSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGL5DDataSetEditor*) (soff+(sizeof(TGL5DDataSetEditor)*i)))->~G__TTGL5DDataSetEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGL5DDataSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGL5DDataSetEditor*) (soff))->~G__TTGL5DDataSetEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLParametricEquation */
static int G__G__GL_355_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLParametricEquation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLParametricEquation(
*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, *(TString*) libp->para[3].ref
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TGLParametricEquation(
*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, *(TString*) libp->para[3].ref
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLParametricEquation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLParametricEquation(
*(TString*) libp->para[0].ref, (ParametricEquation_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGLParametricEquation(
*(TString*) libp->para[0].ref, (ParametricEquation_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t* pobj;
         const Rgl::Range_t xobj = ((const TGLParametricEquation*) G__getstructoffset())->GetURange();
         pobj = new Rgl::Range_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__GL_355_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Rgl::Range_t* pobj;
         const Rgl::Range_t xobj = ((const TGLParametricEquation*) G__getstructoffset())->GetVRange();
         pobj = new Rgl::Range_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__GL_355_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLParametricEquation*) G__getstructoffset())->IsConstrained());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLParametricEquation*) G__getstructoffset())->SetConstrained((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLParametricEquation*) G__getstructoffset())->IsModified());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLParametricEquation*) G__getstructoffset())->SetModified((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLParametricEquation*) G__getstructoffset())->EvalVertex(*(TGLVertex3*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLParametricEquation::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricEquation::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLParametricEquation::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLParametricEquation::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLParametricEquation*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricEquation::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLParametricEquation::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricEquation::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_355_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLParametricEquation::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLParametricEquation G__TTGLParametricEquation;
static int G__G__GL_355_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLParametricEquation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLParametricEquation*) (soff+(sizeof(TGLParametricEquation)*i)))->~G__TTGLParametricEquation();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLParametricEquation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLParametricEquation*) (soff))->~G__TTGLParametricEquation();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLTH3Composition */
static int G__G__GL_356_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTH3Composition* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLTH3Composition[n];
     } else {
       p = new((void*) gvp) TGLTH3Composition[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLTH3Composition;
     } else {
       p = new((void*) gvp) TGLTH3Composition;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGLTH3Composition*) G__getstructoffset())->AddTH3((TH3*) G__int(libp->para[0]), (TGLTH3Composition::ETH3BinShape) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGLTH3Composition*) G__getstructoffset())->AddTH3((TH3*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLTH3Composition::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3Composition::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLTH3Composition::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLTH3Composition::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLTH3Composition*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3Composition::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTH3Composition::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3Composition::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_356_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTH3Composition::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLTH3Composition G__TTGLTH3Composition;
static int G__G__GL_356_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[] (TGLTH3Composition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLTH3Composition*) (soff+(sizeof(TGLTH3Composition)*i)))->~G__TTGLTH3Composition();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLTH3Composition*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLTH3Composition*) (soff))->~G__TTGLTH3Composition();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLHistPainter */
static int G__G__GL_357_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLHistPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLHistPainter((TH1*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLHistPainter((TH1*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLHistPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLHistPainter((TGLParametricEquation*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLHistPainter((TGLParametricEquation*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLHistPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLHistPainter((TGL5DDataSet*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLHistPainter((TGL5DDataSet*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLHistPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLHistPainter((TGLTH3Composition*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLHistPainter((TGLTH3Composition*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLHistPainter*) G__getstructoffset())->GetRealPainter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLHistPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLHistPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLHistPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLHistPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLHistPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLHistPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLHistPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLHistPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_357_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLHistPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLHistPainter G__TTGLHistPainter;
static int G__G__GL_357_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[] (TGLHistPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLHistPainter*) (soff+(sizeof(TGLHistPainter)*i)))->~G__TTGLHistPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLHistPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLHistPainter*) (soff))->~G__TTGLHistPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLAdapter */
static int G__G__GL_368_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAdapter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAdapter((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLAdapter((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLAdapter[n];
       } else {
         p = new((void*) gvp) TGLAdapter[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLAdapter;
       } else {
         p = new((void*) gvp) TGLAdapter;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAdapter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAdapter*) G__getstructoffset())->SetGLDevice((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAdapter*) G__getstructoffset())->ReadGLBuffer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAdapter*) G__getstructoffset())->SelectOffScreenDevice();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAdapter*) G__getstructoffset())->MarkForDirectCopy((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLAdapter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAdapter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLAdapter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLAdapter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAdapter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAdapter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAdapter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAdapter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_368_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAdapter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLAdapter G__TTGLAdapter;
static int G__G__GL_368_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLAdapter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLAdapter*) (soff+(sizeof(TGLAdapter)*i)))->~G__TTGLAdapter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLAdapter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLAdapter*) (soff))->~G__TTGLAdapter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLOvlSelectRecord */
static int G__G__GL_369_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOvlSelectRecord* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLOvlSelectRecord[n];
     } else {
       p = new((void*) gvp) TGLOvlSelectRecord[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLOvlSelectRecord;
     } else {
       p = new((void*) gvp) TGLOvlSelectRecord;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOvlSelectRecord* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLOvlSelectRecord((UInt_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLOvlSelectRecord((UInt_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOvlSelectRecord* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLOvlSelectRecord(*(TGLOvlSelectRecord*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLOvlSelectRecord(*(TGLOvlSelectRecord*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLOvlSelectRecord& obj = ((TGLOvlSelectRecord*) G__getstructoffset())->operator=(*(TGLOvlSelectRecord*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLOvlSelectRecord*) G__getstructoffset())->GetOvlElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOvlSelectRecord*) G__getstructoffset())->SetOvlElement((TGLOverlayElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLOvlSelectRecord::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOvlSelectRecord::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLOvlSelectRecord::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOvlSelectRecord::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOvlSelectRecord*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOvlSelectRecord::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOvlSelectRecord::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOvlSelectRecord::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_369_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOvlSelectRecord::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLOvlSelectRecord G__TTGLOvlSelectRecord;
static int G__G__GL_369_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLOvlSelectRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLOvlSelectRecord*) (soff+(sizeof(TGLOvlSelectRecord)*i)))->~G__TTGLOvlSelectRecord();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLOvlSelectRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLOvlSelectRecord*) (soff))->~G__TTGLOvlSelectRecord();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLOverlayElement */
static int G__G__GL_370_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLOverlayElement*) G__getstructoffset())->MouseEnter(*(TGLOvlSelectRecord*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLOverlayElement*) G__getstructoffset())->MouseStillInside(*(TGLOvlSelectRecord*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLOverlayElement*) G__getstructoffset())->Handle(*(TGLRnrCtx*) libp->para[0].ref, *(TGLOvlSelectRecord*) libp->para[1].ref
, (Event_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->MouseLeave();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->Render(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLOverlayElement*) G__getstructoffset())->GetRole());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->SetRole((TGLOverlayElement::ERole) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLOverlayElement*) G__getstructoffset())->GetState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->SetState((TGLOverlayElement::EState) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->SetBinaryState((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLOverlayElement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayElement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLOverlayElement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOverlayElement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLOverlayElement*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayElement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOverlayElement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayElement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_370_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOverlayElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLOverlayElement G__TTGLOverlayElement;
static int G__G__GL_370_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLOverlayElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLOverlayElement*) (soff+(sizeof(TGLOverlayElement)*i)))->~G__TTGLOverlayElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLOverlayElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLOverlayElement*) (soff))->~G__TTGLOverlayElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLOverlayList */
static int G__G__GL_373_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOverlayList* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLOverlayList[n];
     } else {
       p = new((void*) gvp) TGLOverlayList[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLOverlayList;
     } else {
       p = new((void*) gvp) TGLOverlayList;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLOverlayList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLOverlayList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOverlayList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLOverlayList*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayList*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayList*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOverlayList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_373_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOverlayList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLOverlayList G__TTGLOverlayList;
static int G__G__GL_373_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLOverlayList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLOverlayList*) (soff+(sizeof(TGLOverlayList)*i)))->~G__TTGLOverlayList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLOverlayList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLOverlayList*) (soff))->~G__TTGLOverlayList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLFontManager */
static int G__G__GL_380_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFontManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFontManager[n];
     } else {
       p = new((void*) gvp) TGLFontManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFontManager;
     } else {
       p = new((void*) gvp) TGLFontManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->RegisterFont((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]), *(TGLFont*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->RegisterFont((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]), *(TGLFont*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->ReleaseFont(*(TGLFont*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFontManager::GetFontFileArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFontManager::GetFontSizeArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFontManager::GetFontSize((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFontManager::GetFontSize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFontManager::GetFontNameFromId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->ClearFontTrash();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFontManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFontManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLFontManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFontManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFontManager*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFontManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFontManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFontManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFontManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_380_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFontManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLFontManager G__TTGLFontManager;
static int G__G__GL_380_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLFontManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLFontManager*) (soff+(sizeof(TGLFontManager)*i)))->~G__TTGLFontManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLFontManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLFontManager*) (soff))->~G__TTGLFontManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLFont */
static int G__G__GL_381_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFont* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFont[n];
     } else {
       p = new((void*) gvp) TGLFont[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFont;
     } else {
       p = new((void*) gvp) TGLFont;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFont));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFont* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFont(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]), (FTFont*) G__int(libp->para[3])
, (TGLFontManager*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLFont(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]), (FTFont*) G__int(libp->para[3])
, (TGLFontManager*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFont(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]), (FTFont*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLFont(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]), (FTFont*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFont(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLFont(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGLFont::EMode) 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__GLLN_TGLFont));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFont* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLFont(*(TGLFont*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLFont(*(TGLFont*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFont));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->CopyAttributes(*(TGLFont*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFont*) G__getstructoffset())->GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFont*) G__getstructoffset())->GetFile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFont*) G__getstructoffset())->GetMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFont*) G__getstructoffset())->GetTrashCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLFont*) G__getstructoffset())->SetTrashCount((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLFont*) G__getstructoffset())->IncTrashCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->SetFont((FTFont*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFont*) G__getstructoffset())->GetFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->SetManager((TGLFontManager*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFont*) G__getstructoffset())->GetManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLFont*) G__getstructoffset())->GetDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->SetDepth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLFont*) G__getstructoffset())->GetAscent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLFont*) G__getstructoffset())->GetDescent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLFont*) G__getstructoffset())->GetLineHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((const TGLFont*) G__getstructoffset())->MeasureBaseLineParams(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TGLFont*) G__getstructoffset())->MeasureBaseLineParams(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLFont*) G__getstructoffset())->BBox(
(const char*) G__int(libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3])
, *(Float_t*) G__Floatref(&libp->para[4]), *(Float_t*) G__Floatref(&libp->para[5])
, *(Float_t*) G__Floatref(&libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLFont*) G__getstructoffset())->Render((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLFont*) G__getstructoffset())->Render(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLFont*) G__getstructoffset())->Render(*(TString*) libp->para[0].ref, (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (TGLFont::ETextAlignH_e) G__int(libp->para[4]), (TGLFont::ETextAlignV_e) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TGLFont*) G__getstructoffset())->PreRender((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TGLFont*) G__getstructoffset())->PreRender((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TGLFont*) G__getstructoffset())->PreRender();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLFont*) G__getstructoffset())->PostRender();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLFont*) G__getstructoffset())->operator<(*(TGLFont*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFont::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFont::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLFont::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFont::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFont*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFont*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFont::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFont::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFont::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_381_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFont::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLFont G__TTGLFont;
static int G__G__GL_381_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLFont*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLFont*) (soff+(sizeof(TGLFont)*i)))->~G__TTGLFont();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLFont*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLFont*) (soff))->~G__TTGLFont();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLViewerBase */
static int G__G__GL_402_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLViewerBase* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLViewerBase[n];
     } else {
       p = new((void*) gvp) TGLViewerBase[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLViewerBase;
     } else {
       p = new((void*) gvp) TGLViewerBase;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLViewerBase*) G__getstructoffset())->AddScene((TGLSceneBase*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->RemoveScene((TGLSceneBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->RemoveAllScenes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->SceneDestructing((TGLSceneBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLViewerBase*) G__getstructoffset())->GetSceneInfo((TGLSceneBase*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLViewerBase*) G__getstructoffset())->FindLogicalInScenes((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->AddOverlayElement((TGLOverlayElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->RemoveOverlayElement((TGLOverlayElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->DeleteOverlayAnnotations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->DeleteOverlayElements((TGLOverlayElement::ERole) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewerBase*) G__getstructoffset())->Clip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->SetClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLViewerBase*) G__getstructoffset())->LOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->SetLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLViewerBase*) G__getstructoffset())->Style());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->SetStyle((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewerBase*) G__getstructoffset())->WFLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->SetWFLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLViewerBase*) G__getstructoffset())->OLLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->SetOLLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->ResetSceneInfos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLViewerBase*) G__getstructoffset())->IsChanged());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->MergeSceneBBoxes(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->PreRender();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->Render();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->RenderNonSelected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->RenderSelected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->RenderOverlay((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->PostRender();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->PreRenderOverlaySelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->PostRenderOverlaySelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewerBase*) G__getstructoffset())->ResolveSelectRecord(*(TGLSelectRecord*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewerBase*) G__getstructoffset())->FindClosestRecord(*(TGLSelectRecord*) libp->para[0].ref, *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewerBase*) G__getstructoffset())->FindClosestOpaqueRecord(*(TGLSelectRecord*) libp->para[0].ref, *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLViewerBase*) G__getstructoffset())->FindClosestOverlayRecord(*(TGLOvlSelectRecord*) libp->para[0].ref, *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLViewerBase*) G__getstructoffset())->GetRnrCtx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLRnrCtx& obj = ((const TGLViewerBase*) G__getstructoffset())->RnrCtx();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLViewerBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewerBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLViewerBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLViewerBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewerBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLViewerBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewerBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_402_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLViewerBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLViewerBase G__TTGLViewerBase;
static int G__G__GL_402_0_58(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[] (TGLViewerBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLViewerBase*) (soff+(sizeof(TGLViewerBase)*i)))->~G__TTGLViewerBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLViewerBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLViewerBase*) (soff))->~G__TTGLViewerBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLAnnotation */
static int G__G__GL_404_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAnnotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLAnnotation(
(TGLViewerBase*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGLAnnotation(
(TGLViewerBase*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAnnotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLAnnotation(
(TGLViewerBase*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, *((TGLVector3*) G__int(libp->para[4])));
   } else {
     p = new((void*) gvp) TGLAnnotation(
(TGLViewerBase*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, *((TGLVector3*) G__int(libp->para[4])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetText(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((const TGLAnnotation*) G__getstructoffset())->GetText();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TGLAnnotation*) G__getstructoffset())->GetTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetUseColorSet((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLAnnotation*) G__getstructoffset())->GetUseColorSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetBackColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLAnnotation*) G__getstructoffset())->GetBackColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetTextColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLAnnotation*) G__getstructoffset())->GetTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetTextSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLAnnotation*) G__getstructoffset())->GetTextSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetAllowClose((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLAnnotation*) G__getstructoffset())->GetAllowClose());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLAnnotation*) G__getstructoffset())->GetTextAlign());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->SetTextAlign((TGLFont::ETextAlignH_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->CloseEditor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->UpdateText();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLAnnotation::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAnnotation::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLAnnotation::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLAnnotation::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAnnotation*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAnnotation::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAnnotation::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAnnotation::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_404_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAnnotation::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLAnnotation G__TTGLAnnotation;
static int G__G__GL_404_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLAnnotation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLAnnotation*) (soff+(sizeof(TGLAnnotation)*i)))->~G__TTGLAnnotation();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLAnnotation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLAnnotation*) (soff))->~G__TTGLAnnotation();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLAutoRotator */
static int G__G__GL_408_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAutoRotator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLAutoRotator((TGLViewer*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLAutoRotator((TGLViewer*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLAutoRotator*) G__getstructoffset())->GetCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->Start();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->Stop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->Timeout();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLAutoRotator*) G__getstructoffset())->IsRunning());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLAutoRotator*) G__getstructoffset())->GetDt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->SetDt((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLAutoRotator*) G__getstructoffset())->GetWPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->SetWPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLAutoRotator*) G__getstructoffset())->GetWTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->SetWTheta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLAutoRotator*) G__getstructoffset())->GetATheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->SetATheta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLAutoRotator*) G__getstructoffset())->GetWDolly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->SetWDolly((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLAutoRotator*) G__getstructoffset())->GetADolly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->SetADolly((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLAutoRotator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAutoRotator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLAutoRotator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLAutoRotator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAutoRotator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAutoRotator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAutoRotator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAutoRotator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_408_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAutoRotator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLAutoRotator G__TTGLAutoRotator;
static int G__G__GL_408_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[] (TGLAutoRotator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLAutoRotator*) (soff+(sizeof(TGLAutoRotator)*i)))->~G__TTGLAutoRotator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLAutoRotator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLAutoRotator*) (soff))->~G__TTGLAutoRotator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLText */
static int G__G__GL_409_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLText* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLText[n];
     } else {
       p = new((void*) gvp) TGLText[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLText;
     } else {
       p = new((void*) gvp) TGLText;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLText* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGLText(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLText*) G__getstructoffset())->GetFont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLText*) G__getstructoffset())->SetGLTextAngles((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLText*) G__getstructoffset())->SetGLTextFont((Font_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLText*) G__getstructoffset())->PaintGLText((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLText*) G__getstructoffset())->PaintBBox((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLText*) G__getstructoffset())->BBox(
(const char*) G__int(libp->para[0]), *(float*) G__Floatref(&libp->para[1])
, *(float*) G__Floatref(&libp->para[2]), *(float*) G__Floatref(&libp->para[3])
, *(float*) G__Floatref(&libp->para[4]), *(float*) G__Floatref(&libp->para[5])
, *(float*) G__Floatref(&libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLText::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLText::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLText::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLText::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLText::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLText::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLText::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_409_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLText::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLText G__TTGLText;
static int G__G__GL_409_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLText*) (soff+(sizeof(TGLText)*i)))->~G__TTGLText();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLText*) (soff))->~G__TTGLText();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLAxis */
static int G__G__GL_410_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAxis* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAxis[n];
     } else {
       p = new((void*) gvp) TGLAxis[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAxis;
     } else {
       p = new((void*) gvp) TGLAxis;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAxis));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TGLAxis*) G__getstructoffset())->PaintGLAxis((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TGLAxis*) G__getstructoffset())->PaintGLAxis((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->PaintGLAxisBody();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->PaintGLAxisTickMarks();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->PaintGLAxisLabels();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGLAxis*) G__getstructoffset())->TicksPositions((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGLAxis*) G__getstructoffset())->TicksPositions();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->TicksPositionsNoOpt();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->TicksPositionsOpt();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->DoLabels();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->SetTickMarksLength((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->SetTickMarksOrientation((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->SetLabelsOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->SetLabelsSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->SetGridLength((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->SetLabelsAngles((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLAxis::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxis::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLAxis::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLAxis::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxis*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxis::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAxis::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxis::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_410_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAxis::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLAxis G__TTGLAxis;
static int G__G__GL_410_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLAxis*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLAxis*) (soff+(sizeof(TGLAxis)*i)))->~G__TTGLAxis();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLAxis*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLAxis*) (soff))->~G__TTGLAxis();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLAxisPainter */
static int G__G__GL_412_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAxisPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAxisPainter[n];
     } else {
       p = new((void*) gvp) TGLAxisPainter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAxisPainter;
     } else {
       p = new((void*) gvp) TGLAxisPainter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLAxisPainter*) G__getstructoffset())->GetTMNDim());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetTMNDim((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3& obj = ((TGLAxisPainter*) G__getstructoffset())->RefDir();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3& obj = ((TGLAxisPainter*) G__getstructoffset())->RefTMOff((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLAxisPainter*) G__getstructoffset())->GetFontMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetFontMode((TGLFont::EMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetLabelPixelFontSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLAxisPainter*) G__getstructoffset())->GetLabelPixelFontSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetTitlePixelFontSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLAxisPainter*) G__getstructoffset())->GetTitlePixelFontSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLVector3& obj = ((TGLAxisPainter*) G__getstructoffset())->RefTitlePos();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetLabelAlign((TGLFont::ETextAlignH_e) G__int(libp->para[0]), (TGLFont::ETextAlignV_e) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLAxisPainter::LabVec_t& obj = ((TGLAxisPainter*) G__getstructoffset())->RefLabVec();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLAxisPainter::TMVec_t& obj = ((TGLAxisPainter*) G__getstructoffset())->RefTMVec();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetAttAxis((TAttAxis*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLAxisPainter*) G__getstructoffset())->GetAttAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetUseAxisColors((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLAxisPainter*) G__getstructoffset())->GetUseAxisColors());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLAxisPainter*) G__getstructoffset())->SetLabelFont(*(TGLRnrCtx*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLAxisPainter*) G__getstructoffset())->SetLabelFont(*(TGLRnrCtx*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLAxisPainter*) G__getstructoffset())->SetLabelFont(*(TGLRnrCtx*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGLAxisPainter*) G__getstructoffset())->SetTitleFont(*(TGLRnrCtx*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGLAxisPainter*) G__getstructoffset())->SetTitleFont(*(TGLRnrCtx*) libp->para[0].ref, (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLAxisPainter*) G__getstructoffset())->SetTitleFont(*(TGLRnrCtx*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->SetTextFormat((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLAxisPainter*) G__getstructoffset())->RnrText(*(TString*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, (TGLFont::ETextAlignH_e) G__int(libp->para[2]), (TGLFont::ETextAlignV_e) G__int(libp->para[3])
, *(TGLFont*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLAxisPainter*) G__getstructoffset())->RnrTitle(*(TString*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref
, (TGLFont::ETextAlignH_e) G__int(libp->para[2]), (TGLFont::ETextAlignV_e) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLAxisPainter*) G__getstructoffset())->RnrLabels();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLAxisPainter*) G__getstructoffset())->RnrLines();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->PaintAxis(*(TGLRnrCtx*) libp->para[0].ref, (TAxis*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLAxisPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxisPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLAxisPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLAxisPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLAxisPainter*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxisPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAxisPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxisPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_412_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAxisPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLAxisPainter G__TTGLAxisPainter;
static int G__G__GL_412_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLAxisPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLAxisPainter*) (soff+(sizeof(TGLAxisPainter)*i)))->~G__TTGLAxisPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLAxisPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLAxisPainter*) (soff))->~G__TTGLAxisPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLAxisPainterBox */
static int G__G__GL_423_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLAxisPainterBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAxisPainterBox[n];
     } else {
       p = new((void*) gvp) TGLAxisPainterBox[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLAxisPainterBox;
     } else {
       p = new((void*) gvp) TGLAxisPainterBox;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainterBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainterBox*) G__getstructoffset())->SetAxis3DTitlePos(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainterBox*) G__getstructoffset())->DrawAxis3D(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainterBox*) G__getstructoffset())->PlotStandard(*(TGLRnrCtx*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, *(TGLBoundingBox*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLAxisPainterBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxisPainterBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLAxisPainterBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLAxisPainterBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLAxisPainterBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxisPainterBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAxisPainterBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLAxisPainterBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_423_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLAxisPainterBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLAxisPainterBox G__TTGLAxisPainterBox;
static int G__G__GL_423_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLAxisPainterBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLAxisPainterBox*) (soff+(sizeof(TGLAxisPainterBox)*i)))->~G__TTGLAxisPainterBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLAxisPainterBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLAxisPainterBox*) (soff))->~G__TTGLAxisPainterBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLBoxPainter */
static int G__G__GL_425_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLBoxPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLBoxPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLBoxPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLBoxPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoxPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLBoxPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLBoxPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLBoxPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoxPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBoxPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLBoxPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_425_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLBoxPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLBoxPainter G__TTGLBoxPainter;
static int G__G__GL_425_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLBoxPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLBoxPainter*) (soff+(sizeof(TGLBoxPainter)*i)))->~G__TTGLBoxPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLBoxPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLBoxPainter*) (soff))->~G__TTGLBoxPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLCameraGuide */
static int G__G__GL_427_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLCameraGuide* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLCameraGuide(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (TGLOverlayElement::ERole) G__int(libp->para[3])
, (TGLOverlayElement::EState) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLCameraGuide(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (TGLOverlayElement::ERole) G__int(libp->para[3])
, (TGLOverlayElement::EState) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLCameraGuide(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (TGLOverlayElement::ERole) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLCameraGuide(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (TGLOverlayElement::ERole) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLCameraGuide(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLCameraGuide(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraGuide*) G__getstructoffset())->SetX((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraGuide*) G__getstructoffset())->SetY((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraGuide*) G__getstructoffset())->SetXY((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__GL_427_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraGuide*) G__getstructoffset())->SetSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLCameraGuide::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCameraGuide::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLCameraGuide::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLCameraGuide::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraGuide*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCameraGuide::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCameraGuide::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCameraGuide::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_427_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCameraGuide::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLCameraGuide G__TTGLCameraGuide;
static int G__G__GL_427_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLCameraGuide*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLCameraGuide*) (soff+(sizeof(TGLCameraGuide)*i)))->~G__TTGLCameraGuide();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLCameraGuide*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLCameraGuide*) (soff))->~G__TTGLCameraGuide();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLCameraOverlay */
static int G__G__GL_429_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLCameraOverlay* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLCameraOverlay((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLCameraOverlay((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLCameraOverlay((Bool_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLCameraOverlay((Bool_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLCameraOverlay[n];
       } else {
         p = new((void*) gvp) TGLCameraOverlay[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLCameraOverlay;
       } else {
         p = new((void*) gvp) TGLCameraOverlay;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLPlane& obj = ((TGLCameraOverlay*) G__getstructoffset())->RefExternalRefPlane();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->UseExternalRefPlane((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCameraOverlay*) G__getstructoffset())->GetUseExternalRefPlane());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLCameraOverlay*) G__getstructoffset())->GetPerspectiveMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->SetPerspectiveMode((TGLCameraOverlay::EMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLCameraOverlay*) G__getstructoffset())->GetOrthographicMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->SetOrthographicMode((TGLCameraOverlay::EMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCameraOverlay*) G__getstructoffset())->GetShowOrthographic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->SetShowOrthographic((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLCameraOverlay*) G__getstructoffset())->GetShowPerspective());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->SetShowPerspective((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->SetFrustum(*(TGLCamera*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLCameraOverlay*) G__getstructoffset())->GetAttAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLCameraOverlay::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCameraOverlay::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLCameraOverlay::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLCameraOverlay::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCameraOverlay*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCameraOverlay::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCameraOverlay::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCameraOverlay::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_429_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCameraOverlay::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLCameraOverlay G__TTGLCameraOverlay;
static int G__G__GL_429_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLCameraOverlay*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLCameraOverlay*) (soff+(sizeof(TGLCameraOverlay)*i)))->~G__TTGLCameraOverlay();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLCameraOverlay*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLCameraOverlay*) (soff))->~G__TTGLCameraOverlay();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPShapeRef */
static int G__G__GL_431_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPShapeRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeRef[n];
     } else {
       p = new((void*) gvp) TGLPShapeRef[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeRef;
     } else {
       p = new((void*) gvp) TGLPShapeRef;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPShapeRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPShapeRef((TGLPhysicalShape*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLPShapeRef((TGLPhysicalShape*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPShapeRef*) G__getstructoffset())->GetPShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeRef*) G__getstructoffset())->SetPShape((TGLPhysicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeRef*) G__getstructoffset())->PShapeModified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPShapeRef::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeRef::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPShapeRef::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPShapeRef::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLPShapeRef*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeRef*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeRef*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeRef*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeRef::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPShapeRef::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeRef::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_431_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPShapeRef::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPShapeRef G__TTGLPShapeRef;
static int G__G__GL_431_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPShapeRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPShapeRef*) (soff+(sizeof(TGLPShapeRef)*i)))->~G__TTGLPShapeRef();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPShapeRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPShapeRef*) (soff))->~G__TTGLPShapeRef();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLManipSet */
static int G__G__GL_433_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLManipSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLManipSet[n];
     } else {
       p = new((void*) gvp) TGLManipSet[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLManipSet;
     } else {
       p = new((void*) gvp) TGLManipSet;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLManipSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLManipSet*) G__getstructoffset())->GetCurrentManip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLManipSet*) G__getstructoffset())->GetManipType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManipSet*) G__getstructoffset())->SetManipType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLManipSet*) G__getstructoffset())->GetDrawBBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManipSet*) G__getstructoffset())->SetDrawBBox((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLManipSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManipSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLManipSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLManipSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLManipSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManipSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLManipSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLManipSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_433_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLManipSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLManipSet G__TTGLManipSet;
static int G__G__GL_433_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLManipSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLManipSet*) (soff+(sizeof(TGLManipSet)*i)))->~G__TTGLManipSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLManipSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLManipSet*) (soff))->~G__TTGLManipSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLClip */
static int G__G__GL_434_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClip*) G__getstructoffset())->Setup(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClip*) G__getstructoffset())->Setup(*(TGLVector3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLClip*) G__getstructoffset())->GetMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClip*) G__getstructoffset())->SetMode((TGLClip::EMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLClip*) G__getstructoffset())->TimeStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClip*) G__getstructoffset())->IncTimeStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLClip*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClip*) G__getstructoffset())->Invalidate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLClip*) G__getstructoffset())->PlaneSet(*(TGLPlaneSet_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLClip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLClip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLClip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_434_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLClip G__TTGLClip;
static int G__G__GL_434_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLClip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLClip*) (soff+(sizeof(TGLClip)*i)))->~G__TTGLClip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLClip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLClip*) (soff))->~G__TTGLClip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLClipPlane */
static int G__G__GL_436_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLClipPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipPlane[n];
     } else {
       p = new((void*) gvp) TGLClipPlane[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipPlane;
     } else {
       p = new((void*) gvp) TGLClipPlane;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipPlane*) G__getstructoffset())->Set(*(TGLPlane*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLClipPlane::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipPlane::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLClipPlane::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLClipPlane::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipPlane*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipPlane::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipPlane::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipPlane::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_436_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipPlane::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLClipPlane G__TTGLClipPlane;
static int G__G__GL_436_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLClipPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLClipPlane*) (soff+(sizeof(TGLClipPlane)*i)))->~G__TTGLClipPlane();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLClipPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLClipPlane*) (soff))->~G__TTGLClipPlane();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLClipBox */
static int G__G__GL_437_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLClipBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipBox[n];
     } else {
       p = new((void*) gvp) TGLClipBox[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipBox;
     } else {
       p = new((void*) gvp) TGLClipBox;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLClipBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLClipBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLClipBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLClipBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_437_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLClipBox G__TTGLClipBox;
static int G__G__GL_437_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLClipBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLClipBox*) (soff+(sizeof(TGLClipBox)*i)))->~G__TTGLClipBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLClipBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLClipBox*) (soff))->~G__TTGLClipBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLClipSet */
static int G__G__GL_438_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLClipSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipSet[n];
     } else {
       p = new((void*) gvp) TGLClipSet[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipSet;
     } else {
       p = new((void*) gvp) TGLClipSet;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLClipSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLClipSet*) G__getstructoffset())->IsClipping());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLClipSet*) G__getstructoffset())->GetCurrentClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLClipSet*) G__getstructoffset())->FillPlaneSet(*(TGLPlaneSet_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetupClips(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetupCurrentClip(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetupCurrentClipIfInvalid(*(TGLBoundingBox*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->InvalidateClips();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->InvalidateCurrentClip();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLClipSet*) G__getstructoffset())->GetClipState((EClipType) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetClipState((EClipType) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLClipSet*) G__getstructoffset())->GetClipType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetClipType((EClipType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLClipSet*) G__getstructoffset())->GetAutoUpdate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetAutoUpdate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLClipSet*) G__getstructoffset())->GetShowManip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetShowManip((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLClipSet*) G__getstructoffset())->GetShowClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->SetShowClip((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLClipSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLClipSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLClipSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_438_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLClipSet G__TTGLClipSet;
static int G__G__GL_438_0_39(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[] (TGLClipSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLClipSet*) (soff+(sizeof(TGLClipSet)*i)))->~G__TTGLClipSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLClipSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLClipSet*) (soff))->~G__TTGLClipSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLClipSetSubEditor */
static int G__G__GL_441_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLClipSetSubEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLClipSetSubEditor((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLClipSetSubEditor((TGWindow*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->SetModel((TGLClipSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->ClipValueChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->ClipTypeChanged((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->UpdateViewerClip();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->ResetViewerClip();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLClipSetSubEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSetSubEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLClipSetSubEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLClipSetSubEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetSubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSetSubEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipSetSubEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSetSubEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_441_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipSetSubEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLClipSetSubEditor G__TTGLClipSetSubEditor;
static int G__G__GL_441_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[] (TGLClipSetSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLClipSetSubEditor*) (soff+(sizeof(TGLClipSetSubEditor)*i)))->~G__TTGLClipSetSubEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLClipSetSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLClipSetSubEditor*) (soff))->~G__TTGLClipSetSubEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLClipSetEditor */
static int G__G__GL_442_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLClipSetEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLClipSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLClipSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLClipSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLClipSetEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLClipSetEditor((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 TGLClipSetEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLClipSetEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLClipSetEditor[n];
       } else {
         p = new((void*) gvp) TGLClipSetEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLClipSetEditor;
       } else {
         p = new((void*) gvp) TGLClipSetEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLClipSetEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSetEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLClipSetEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLClipSetEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLClipSetEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSetEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipSetEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLClipSetEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_442_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLClipSetEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLClipSetEditor G__TTGLClipSetEditor;
static int G__G__GL_442_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[] (TGLClipSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLClipSetEditor*) (soff+(sizeof(TGLClipSetEditor)*i)))->~G__TTGLClipSetEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLClipSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLClipSetEditor*) (soff))->~G__TTGLClipSetEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLContextIdentity */
static int G__G__GL_443_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLContextIdentity* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLContextIdentity[n];
     } else {
       p = new((void*) gvp) TGLContextIdentity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLContextIdentity;
     } else {
       p = new((void*) gvp) TGLContextIdentity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->AddRef((TGLContext*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->Release((TGLContext*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->AddClientRef();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->ReleaseClient();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLContextIdentity*) G__getstructoffset())->GetRefCnt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLContextIdentity*) G__getstructoffset())->GetClientRefCnt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLContextIdentity*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->RegisterDLNameRangeToWipe((UInt_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__GL_443_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->DeleteGLResources();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLContextIdentity::GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLContextIdentity::GetDefaultIdentity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLContextIdentity::GetDefaultContextAny());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLContextIdentity*) G__getstructoffset())->GetFontManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLContextIdentity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLContextIdentity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLContextIdentity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLContextIdentity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLContextIdentity*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLContextIdentity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLContextIdentity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLContextIdentity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLContextIdentity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_443_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLContextIdentity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_443_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLContextIdentity* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLContextIdentity(*(TGLContextIdentity*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLContextIdentity G__TTGLContextIdentity;
static int G__G__GL_443_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLContextIdentity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLContextIdentity*) (soff+(sizeof(TGLContextIdentity)*i)))->~G__TTGLContextIdentity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLContextIdentity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLContextIdentity*) (soff))->~G__TTGLContextIdentity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_443_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLContextIdentity* dest = (TGLContextIdentity*) G__getstructoffset();
   *dest = *(TGLContextIdentity*) libp->para[0].ref;
   const TGLContextIdentity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLWidget */
static int G__G__GL_446_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLWidget::CreateDummy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLWidget::Create((TGWindow*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (TGLPaintDevice*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLWidget::Create(
*(TGLFormat*) libp->para[0].ref, (TGWindow*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (TGLPaintDevice*) 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__GL_446_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLWidget*) G__getstructoffset())->InitGL();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLWidget*) G__getstructoffset())->PaintGL();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLWidget*) G__getstructoffset())->ClearCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLWidget*) G__getstructoffset())->SetFormat();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLWidget*) G__getstructoffset())->GetEventHandler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLWidget*) G__getstructoffset())->SetEventHandler((TGEventHandler*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLWidget::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLWidget::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLWidget::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLWidget::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLWidget*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLWidget::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLWidget::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLWidget::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_446_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLWidget::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLWidget G__TTGLWidget;
static int G__G__GL_446_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[] (TGLWidget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLWidget*) (soff+(sizeof(TGLWidget)*i)))->~G__TTGLWidget();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLWidget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLWidget*) (soff))->~G__TTGLWidget();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLCylinder */
static int G__G__GL_457_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLCylinder* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLCylinder(*(TBuffer3DTube*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLCylinder(*(TBuffer3DTube*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLCylinder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLCylinder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCylinder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLCylinder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLCylinder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLCylinder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCylinder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCylinder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLCylinder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_457_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLCylinder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLCylinder G__TTGLCylinder;
static int G__G__GL_457_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLCylinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLCylinder*) (soff+(sizeof(TGLCylinder)*i)))->~G__TTGLCylinder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLCylinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLCylinder*) (soff))->~G__TTGLCylinder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLockable */
static int G__G__GL_458_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLockable* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLockable[n];
     } else {
       p = new((void*) gvp) TGLLockable[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLockable;
     } else {
       p = new((void*) gvp) TGLLockable;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLockable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGLLockable*) G__getstructoffset())->LockIdStr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLockable*) G__getstructoffset())->TakeLock((TGLLockable::ELock) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLockable*) G__getstructoffset())->ReleaseLock((TGLLockable::ELock) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLockable*) G__getstructoffset())->IsLocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLLockable*) G__getstructoffset())->CurrentLock());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLockable*) G__getstructoffset())->IsDrawOrSelectLock());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLockable::LockName((TGLLockable::ELock) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGLLockable::LockValid((TGLLockable::ELock) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLockable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLockable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLockable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLockable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLLockable*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLockable*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLockable*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLockable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLockable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLockable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLockable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_458_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLockable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLockable G__TTGLLockable;
static int G__G__GL_458_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLLockable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLockable*) (soff+(sizeof(TGLLockable)*i)))->~G__TTGLLockable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLockable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLockable*) (soff))->~G__TTGLLockable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSceneInfo */
static int G__G__GL_461_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSceneInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSceneInfo((TGLViewerBase*) G__int(libp->para[0]), (TGLSceneBase*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLSceneInfo((TGLViewerBase*) G__int(libp->para[0]), (TGLSceneBase*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSceneInfo((TGLViewerBase*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLSceneInfo((TGLViewerBase*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLSceneInfo[n];
       } else {
         p = new((void*) gvp) TGLSceneInfo[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLSceneInfo;
       } else {
         p = new((void*) gvp) TGLSceneInfo;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneInfo*) G__getstructoffset())->GetViewer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLViewerBase& obj = ((const TGLSceneInfo*) G__getstructoffset())->RefViewer();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneInfo*) G__getstructoffset())->GetScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLSceneBase& obj = ((const TGLSceneInfo*) G__getstructoffset())->RefScene();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->GetActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetupTransformsAndBBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLBoundingBox& obj = ((TGLSceneInfo*) G__getstructoffset())->GetTransformedBBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetSceneTrans(*(TGLMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->ViewCheck());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ViewCheck((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->IsInFrustum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->InFrustum((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->IsInClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->InClip((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TGLSceneInfo*) G__getstructoffset())->ClipMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ClipMode((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->ShouldClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->IsVisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TGLPlane>& obj = ((TGLSceneInfo*) G__getstructoffset())->FrustumPlanes();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TGLPlane>& obj = ((TGLSceneInfo*) G__getstructoffset())->ClipPlanes();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLSceneInfo*) G__getstructoffset())->LOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLSceneInfo*) G__getstructoffset())->Style());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetStyle((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLSceneInfo*) G__getstructoffset())->WFLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetWFLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLSceneInfo*) G__getstructoffset())->OLLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetOLLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneInfo*) G__getstructoffset())->Clip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLSceneInfo*) G__getstructoffset())->LastLOD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLastLOD((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TGLSceneInfo*) G__getstructoffset())->LastStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLastStyle((Short_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLSceneInfo*) G__getstructoffset())->LastWFLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLastWFLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLSceneInfo*) G__getstructoffset())->LastOLLineW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLastOLLineW((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneInfo*) G__getstructoffset())->LastClip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLastClip((TGLClip*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneInfo*) G__getstructoffset())->LastCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetLastCamera((TGLCamera*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSceneInfo*) G__getstructoffset())->SceneStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetSceneStamp((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ResetSceneStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSceneInfo*) G__getstructoffset())->ClipStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetClipStamp((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ResetClipStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSceneInfo*) G__getstructoffset())->CameraStamp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->SetCameraStamp((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ResetCameraStamp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLSceneInfo*) G__getstructoffset())->HasUpdateTimeouted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->UpdateTimeouted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ResetUpdateTimeouted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSceneInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSceneInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSceneInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSceneInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSceneInfo*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSceneInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSceneInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSceneInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSceneInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_461_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSceneInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSceneInfo G__TTGLSceneInfo;
static int G__G__GL_461_0_71(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[] (TGLSceneInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSceneInfo*) (soff+(sizeof(TGLSceneInfo)*i)))->~G__TTGLSceneInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSceneInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSceneInfo*) (soff))->~G__TTGLSceneInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLStopwatch */
static int G__G__GL_472_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLStopwatch* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLStopwatch[n];
     } else {
       p = new((void*) gvp) TGLStopwatch[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLStopwatch;
     } else {
       p = new((void*) gvp) TGLStopwatch;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLStopwatch*) G__getstructoffset())->Start();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLStopwatch*) G__getstructoffset())->Lap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGLStopwatch*) G__getstructoffset())->End());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLStopwatch*) G__getstructoffset())->LastRun());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLStopwatch::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLStopwatch::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLStopwatch::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLStopwatch::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLStopwatch*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLStopwatch*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLStopwatch*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLStopwatch*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLStopwatch::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLStopwatch::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLStopwatch::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_472_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLStopwatch::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_472_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLStopwatch* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLStopwatch(*(TGLStopwatch*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLStopwatch G__TTGLStopwatch;
static int G__G__GL_472_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLStopwatch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLStopwatch*) (soff+(sizeof(TGLStopwatch)*i)))->~G__TTGLStopwatch();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLStopwatch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLStopwatch*) (soff))->~G__TTGLStopwatch();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_472_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLStopwatch* dest = (TGLStopwatch*) G__getstructoffset();
   *dest = *(TGLStopwatch*) libp->para[0].ref;
   const TGLStopwatch& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSelectBuffer */
static int G__G__GL_473_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectBuffer* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectBuffer[n];
     } else {
       p = new((void*) gvp) TGLSelectBuffer[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectBuffer;
     } else {
       p = new((void*) gvp) TGLSelectBuffer;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLSelectBuffer*) G__getstructoffset())->GetBufSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((const TGLSelectBuffer*) G__getstructoffset())->GetBuf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLSelectBuffer*) G__getstructoffset())->GetNRecords());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLSelectBuffer*) G__getstructoffset())->CanGrow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectBuffer*) G__getstructoffset())->Grow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectBuffer*) G__getstructoffset())->ProcessResult((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((TGLSelectBuffer*) G__getstructoffset())->RawRecord((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectBuffer*) G__getstructoffset())->SelectRecord(*(TGLSelectRecordBase*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSelectBuffer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectBuffer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSelectBuffer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSelectBuffer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSelectBuffer*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectBuffer*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectBuffer*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectBuffer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectBuffer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectBuffer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectBuffer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_473_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectBuffer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_473_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLSelectBuffer* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLSelectBuffer(*(TGLSelectBuffer*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSelectBuffer G__TTGLSelectBuffer;
static int G__G__GL_473_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLSelectBuffer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSelectBuffer*) (soff+(sizeof(TGLSelectBuffer)*i)))->~G__TTGLSelectBuffer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSelectBuffer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSelectBuffer*) (soff))->~G__TTGLSelectBuffer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_473_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectBuffer* dest = (TGLSelectBuffer*) G__getstructoffset();
   *dest = *(TGLSelectBuffer*) libp->para[0].ref;
   const TGLSelectBuffer& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSelectRecordBase */
static int G__G__GL_482_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectRecordBase* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectRecordBase[n];
     } else {
       p = new((void*) gvp) TGLSelectRecordBase[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSelectRecordBase;
     } else {
       p = new((void*) gvp) TGLSelectRecordBase;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectRecordBase* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSelectRecordBase((UInt_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLSelectRecordBase((UInt_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSelectRecordBase* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSelectRecordBase(*(TGLSelectRecordBase*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLSelectRecordBase(*(TGLSelectRecordBase*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGLSelectRecordBase& obj = ((TGLSelectRecordBase*) G__getstructoffset())->operator=(*(TGLSelectRecordBase*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->SetRawOnly((UInt_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->Set((UInt_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLSelectRecordBase*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((const TGLSelectRecordBase*) G__getstructoffset())->GetItems());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSelectRecordBase*) G__getstructoffset())->GetItem((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLSelectRecordBase*) G__getstructoffset())->GetMinZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLSelectRecordBase*) G__getstructoffset())->GetMaxZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGLSelectRecordBase*) G__getstructoffset())->GetCurrItem());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLSelectRecordBase*) G__getstructoffset())->GetNLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->NextPos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->PrevPos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->ResetPos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSelectRecordBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectRecordBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSelectRecordBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSelectRecordBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSelectRecordBase*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSelectRecordBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectRecordBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectRecordBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSelectRecordBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_482_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSelectRecordBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSelectRecordBase G__TTGLSelectRecordBase;
static int G__G__GL_482_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLSelectRecordBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSelectRecordBase*) (soff+(sizeof(TGLSelectRecordBase)*i)))->~G__TTGLSelectRecordBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSelectRecordBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSelectRecordBase*) (soff))->~G__TTGLSelectRecordBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPerspectiveCamera */
static int G__G__GL_489_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPerspectiveCamera* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPerspectiveCamera(*(TGLVector3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLPerspectiveCamera(*(TGLVector3*) libp->para[0].ref, *(TGLVector3*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLPerspectiveCamera*) G__getstructoffset())->GetFOV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPerspectiveCamera::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPerspectiveCamera::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPerspectiveCamera::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPerspectiveCamera::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPerspectiveCamera*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPerspectiveCamera::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPerspectiveCamera::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPerspectiveCamera::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_489_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPerspectiveCamera::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPerspectiveCamera G__TTGLPerspectiveCamera;
static int G__G__GL_489_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPerspectiveCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPerspectiveCamera*) (soff+(sizeof(TGLPerspectiveCamera)*i)))->~G__TTGLPerspectiveCamera();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPerspectiveCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPerspectiveCamera*) (soff))->~G__TTGLPerspectiveCamera();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLOrthoCamera */
static int G__G__GL_490_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOrthoCamera* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLOrthoCamera(
(TGLOrthoCamera::EType) G__int(libp->para[0]), *(TGLVector3*) libp->para[1].ref
, *(TGLVector3*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TGLOrthoCamera(
(TGLOrthoCamera::EType) G__int(libp->para[0]), *(TGLVector3*) libp->para[1].ref
, *(TGLVector3*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOrthoCamera*) G__getstructoffset())->SetEnableRotate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLOrthoCamera*) G__getstructoffset())->GetEnableRotate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLOrthoCamera*) G__getstructoffset())->GetZoomMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGLOrthoCamera*) G__getstructoffset())->GetZoomMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOrthoCamera*) G__getstructoffset())->SetZoomMin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOrthoCamera*) G__getstructoffset())->SetZoomMax((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOrthoCamera*) G__getstructoffset())->SetZoomMinMax((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOrthoCamera*) G__getstructoffset())->SetDollyToZoom((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLOrthoCamera*) G__getstructoffset())->GetDollyToZoom());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLOrthoCamera::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOrthoCamera::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLOrthoCamera::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOrthoCamera::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOrthoCamera*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOrthoCamera::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOrthoCamera::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOrthoCamera::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_490_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOrthoCamera::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLOrthoCamera G__TTGLOrthoCamera;
static int G__G__GL_490_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLOrthoCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLOrthoCamera*) (soff+(sizeof(TGLOrthoCamera)*i)))->~G__TTGLOrthoCamera();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLOrthoCamera*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLOrthoCamera*) (soff))->~G__TTGLOrthoCamera();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLViewerEditor */
static int G__G__GL_502_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLViewerEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLViewerEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLViewerEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLViewerEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLViewerEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLViewerEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLViewerEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLViewerEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLViewerEditor((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 TGLViewerEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLViewerEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLViewerEditor[n];
       } else {
         p = new((void*) gvp) TGLViewerEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLViewerEditor;
       } else {
         p = new((void*) gvp) TGLViewerEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->ViewerRedraw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->SetGuides();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoClearColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoIgnoreSizesOnUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoResetCamerasOnUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoUpdateScene();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoCameraHome();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdateMaxDrawTimes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdatePointLineStuff();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoCameraCenterExt();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoCaptureCenter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoAnnotation();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoDrawCameraCenter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdateCameraCenter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdateViewerAxes((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdateViewerReference();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoCameraOverlay();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdateRotator();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoRotatorStart();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DoRotatorStop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->UpdateStereo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->DetachFromPad();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) TGLViewerEditor::MakeLabeledNEntry((TGCompositeFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) TGLViewerEditor::MakeLabeledNEntry((TGCompositeFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TGLViewerEditor::MakeLabeledNEntry((TGCompositeFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLViewerEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewerEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLViewerEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLViewerEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLViewerEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewerEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLViewerEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLViewerEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_502_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLViewerEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLViewerEditor G__TTGLViewerEditor;
static int G__G__GL_502_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[] (TGLViewerEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLViewerEditor*) (soff+(sizeof(TGLViewerEditor)*i)))->~G__TTGLViewerEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLViewerEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLViewerEditor*) (soff))->~G__TTGLViewerEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLightSet */
static int G__G__GL_503_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLightSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLightSet[n];
     } else {
       p = new((void*) gvp) TGLLightSet[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLightSet;
     } else {
       p = new((void*) gvp) TGLLightSet;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLightSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->ToggleLight((TGLLightSet::ELight) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->SetLight((TGLLightSet::ELight) 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__GL_503_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TGLLightSet*) G__getstructoffset())->GetLightState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLLightSet*) G__getstructoffset())->GetUseSpecular());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->SetUseSpecular((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLLightSet*) G__getstructoffset())->GetFrontPower());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLLightSet*) G__getstructoffset())->GetSidePower());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TGLLightSet*) G__getstructoffset())->GetSpecularPower());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->SetFrontPower((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->SetSidePower((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->SetSpecularPower((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGLLightSet*) G__getstructoffset())->StdSetupLights(*(TGLBoundingBox*) libp->para[0].ref, *(TGLCamera*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLLightSet*) G__getstructoffset())->StdSetupLights(*(TGLBoundingBox*) libp->para[0].ref, *(TGLCamera*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLightSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLightSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLightSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLightSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_503_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLightSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLightSet G__TTGLLightSet;
static int G__G__GL_503_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLLightSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLightSet*) (soff+(sizeof(TGLLightSet)*i)))->~G__TTGLLightSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLightSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLightSet*) (soff))->~G__TTGLLightSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPShapeObj */
static int G__G__GL_504_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPShapeObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeObj[n];
     } else {
       p = new((void*) gvp) TGLPShapeObj[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeObj;
     } else {
       p = new((void*) gvp) TGLPShapeObj;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPShapeObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPShapeObj((TGLPhysicalShape*) G__int(libp->para[0]), (TGLViewer*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGLPShapeObj((TGLPhysicalShape*) G__int(libp->para[0]), (TGLViewer*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPShapeObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPShapeObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPShapeObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPShapeObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_504_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPShapeObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPShapeObj G__TTGLPShapeObj;
static int G__G__GL_504_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[] (TGLPShapeObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPShapeObj*) (soff+(sizeof(TGLPShapeObj)*i)))->~G__TTGLPShapeObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPShapeObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPShapeObj*) (soff))->~G__TTGLPShapeObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLOutput */
static int G__G__GL_505_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) TGLOutput::Capture(*(TGLViewer*) libp->para[0].ref, (TGLOutput::EFormat) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TGLOutput::Capture(*(TGLViewer*) libp->para[0].ref, (TGLOutput::EFormat) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOutput::StartEmbeddedPS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOutput::CloseEmbeddedPS();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOutput::Capture(*(TGLViewer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLOutput::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOutput::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLOutput::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOutput::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLOutput*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOutput*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOutput*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOutput*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOutput::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOutput::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOutput::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_505_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOutput::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__G__GL_505_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOutput *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLOutput[n];
     } else {
       p = new((void*) gvp) TGLOutput[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLOutput;
     } else {
       p = new((void*) gvp) TGLOutput;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOutput));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_505_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLOutput* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLOutput(*(TGLOutput*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOutput));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLOutput G__TTGLOutput;
static int G__G__GL_505_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLOutput*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLOutput*) (soff+(sizeof(TGLOutput)*i)))->~G__TTGLOutput();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLOutput*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLOutput*) (soff))->~G__TTGLOutput();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__GL_505_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOutput* dest = (TGLOutput*) G__getstructoffset();
   *dest = *(TGLOutput*) libp->para[0].ref;
   const TGLOutput& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLEventHandler */
static int G__G__GL_506_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLEventHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLEventHandler((TGWindow*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGLEventHandler((TGWindow*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLEventHandler*) G__getstructoffset())->HandleExpose((Event_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->StartMouseTimer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->StopMouseTimer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->ClearMouseOver();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->PopupContextMenu((TGLPhysicalShape*) G__int(libp->para[0]), (Event_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__GL_506_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->TriggerTooltip((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->RemoveTooltip();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->SetMouseOverSelectDelay((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->SetMouseOverTooltipDelay((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLEventHandler*) G__getstructoffset())->GetTooltipPixelTolerance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->SetTooltipPixelTolerance((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGLEventHandler*) G__getstructoffset())->GetSecSelType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->SetSecSelType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLEventHandler*) G__getstructoffset())->GetDoInternalSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->SetDoInternalSelection((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLEventHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLEventHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLEventHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLEventHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEventHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLEventHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLEventHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLEventHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_506_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLEventHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLEventHandler G__TTGLEventHandler;
static int G__G__GL_506_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[] (TGLEventHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLEventHandler*) (soff+(sizeof(TGLEventHandler)*i)))->~G__TTGLEventHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLEventHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLEventHandler*) (soff))->~G__TTGLEventHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLFaderHelper */
static int G__G__GL_511_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFaderHelper* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFaderHelper[n];
     } else {
       p = new((void*) gvp) TGLFaderHelper[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFaderHelper;
     } else {
       p = new((void*) gvp) TGLFaderHelper;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFaderHelper* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLFaderHelper(
(TGLViewer*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGLFaderHelper(
(TGLViewer*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaderHelper*) G__getstructoffset())->MakeFadeStep();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFaderHelper::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFaderHelper::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLFaderHelper::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFaderHelper::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFaderHelper*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaderHelper*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaderHelper*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaderHelper*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFaderHelper::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFaderHelper::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFaderHelper::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_511_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFaderHelper::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLFaderHelper G__TTGLFaderHelper;
static int G__G__GL_511_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLFaderHelper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLFaderHelper*) (soff+(sizeof(TGLFaderHelper)*i)))->~G__TTGLFaderHelper();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLFaderHelper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLFaderHelper*) (soff))->~G__TTGLFaderHelper();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLEmbeddedViewer */
static int G__G__GL_513_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLEmbeddedViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLEmbeddedViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLEmbeddedViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) 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 TGLEmbeddedViewer((TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLEmbeddedViewer((TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLEmbeddedViewer((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLEmbeddedViewer((TGWindow*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLEmbeddedViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLEmbeddedViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLEmbeddedViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) 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 TGLEmbeddedViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLEmbeddedViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) 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__GLLN_TGLEmbeddedViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLEmbeddedViewer*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLEmbeddedViewer*) G__getstructoffset())->GetOrthoXOYCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLEmbeddedViewer*) G__getstructoffset())->GetOrthoXOZCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGLEmbeddedViewer*) G__getstructoffset())->GetOrthoZOYCamera());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLEmbeddedViewer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLEmbeddedViewer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLEmbeddedViewer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLEmbeddedViewer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLEmbeddedViewer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLEmbeddedViewer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLEmbeddedViewer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLEmbeddedViewer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_513_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLEmbeddedViewer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLEmbeddedViewer G__TTGLEmbeddedViewer;
static int G__G__GL_513_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[] (TGLEmbeddedViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLEmbeddedViewer*) (soff+(sizeof(TGLEmbeddedViewer)*i)))->~G__TTGLEmbeddedViewer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLEmbeddedViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLEmbeddedViewer*) (soff))->~G__TTGLEmbeddedViewer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLFaceSet */
static int G__G__GL_516_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFaceSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLFaceSet(*(TBuffer3D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLFaceSet(*(TBuffer3D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaceSet*) G__getstructoffset())->SetFromMesh((RootCsg::TBaseMesh*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaceSet*) G__getstructoffset())->CalculateNormals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaceSet*) G__getstructoffset())->EnforceTriangles();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Double_t>& obj = ((TGLFaceSet*) G__getstructoffset())->GetVertices();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Double_t>& obj = ((TGLFaceSet*) G__getstructoffset())->GetNormals();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((TGLFaceSet*) G__getstructoffset())->GetPolyDesc();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TGLFaceSet*) G__getstructoffset())->GetNbPols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGLFaceSet::GetEnforceTriangles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFaceSet::SetEnforceTriangles((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFaceSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFaceSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLFaceSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFaceSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFaceSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFaceSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFaceSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFaceSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_516_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFaceSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLFaceSet G__TTGLFaceSet;
static int G__G__GL_516_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLFaceSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLFaceSet*) (soff+(sizeof(TGLFaceSet)*i)))->~G__TTGLFaceSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLFaceSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLFaceSet*) (soff))->~G__TTGLFaceSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLFBO */
static int G__G__GL_517_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLFBO* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFBO[n];
     } else {
       p = new((void*) gvp) TGLFBO[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLFBO;
     } else {
       p = new((void*) gvp) TGLFBO;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLFBO));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGLFBO*) G__getstructoffset())->Init((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGLFBO*) G__getstructoffset())->Init((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->Release();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->Bind();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->Unbind();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->BindTexture();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->UnbindTexture();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->SetAsReadBuffer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLFBO::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFBO::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLFBO::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLFBO::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLFBO*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLFBO*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFBO::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFBO::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLFBO::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_517_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLFBO::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLFBO G__TTGLFBO;
static int G__G__GL_517_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLFBO*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLFBO*) (soff+(sizeof(TGLFBO)*i)))->~G__TTGLFBO();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLFBO*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLFBO*) (soff))->~G__TTGLFBO();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPadPainter */
static int G__G__GL_518_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPadPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPadPainter[n];
     } else {
       p = new((void*) gvp) TGLPadPainter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPadPainter;
     } else {
       p = new((void*) gvp) TGLPadPainter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPadPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPadPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPadPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPadPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPadPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPadPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPadPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPadPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_518_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPadPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPadPainter G__TTGLPadPainter;
static int G__G__GL_518_0_68(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[] (TGLPadPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPadPainter*) (soff+(sizeof(TGLPadPainter)*i)))->~G__TTGLPadPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPadPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPadPainter*) (soff))->~G__TTGLPadPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLH2PolyPainter */
static int G__G__GL_542_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLH2PolyPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLH2PolyPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLH2PolyPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLH2PolyPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLH2PolyPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLH2PolyPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLH2PolyPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLH2PolyPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLH2PolyPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLH2PolyPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLH2PolyPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_542_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLH2PolyPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLH2PolyPainter G__TTGLH2PolyPainter;
static int G__G__GL_542_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLH2PolyPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLH2PolyPainter*) (soff+(sizeof(TGLH2PolyPainter)*i)))->~G__TTGLH2PolyPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLH2PolyPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLH2PolyPainter*) (soff))->~G__TTGLH2PolyPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLegoPainter */
static int G__G__GL_547_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLegoPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLLegoPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLLegoPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLegoPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLegoPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLegoPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLegoPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLegoPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLegoPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLegoPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLegoPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_547_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLegoPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLegoPainter G__TTGLLegoPainter;
static int G__G__GL_547_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLLegoPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLegoPainter*) (soff+(sizeof(TGLLegoPainter)*i)))->~G__TTGLLegoPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLegoPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLegoPainter*) (soff))->~G__TTGLLegoPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLightSetSubEditor */
static int G__G__GL_553_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLightSetSubEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLLightSetSubEditor((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLLightSetSubEditor((TGWindow*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSetSubEditor*) G__getstructoffset())->SetModel((TGLLightSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSetSubEditor*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSetSubEditor*) G__getstructoffset())->DoButton();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLightSetSubEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSetSubEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLightSetSubEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLightSetSubEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSetSubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSetSubEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLightSetSubEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSetSubEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_553_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLightSetSubEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLightSetSubEditor G__TTGLLightSetSubEditor;
static int G__G__GL_553_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[] (TGLLightSetSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLightSetSubEditor*) (soff+(sizeof(TGLLightSetSubEditor)*i)))->~G__TTGLLightSetSubEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLightSetSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLightSetSubEditor*) (soff))->~G__TTGLLightSetSubEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLLightSetEditor */
static int G__G__GL_554_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLLightSetEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLightSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLLightSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLightSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLLightSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLightSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLLightSetEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLLightSetEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLLightSetEditor((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 TGLLightSetEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLLightSetEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLLightSetEditor[n];
       } else {
         p = new((void*) gvp) TGLLightSetEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLLightSetEditor;
       } else {
         p = new((void*) gvp) TGLLightSetEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLLightSetEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSetEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLLightSetEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLLightSetEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLLightSetEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSetEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLightSetEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLLightSetEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_554_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLLightSetEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLLightSetEditor G__TTGLLightSetEditor;
static int G__G__GL_554_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[] (TGLLightSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLLightSetEditor*) (soff+(sizeof(TGLLightSetEditor)*i)))->~G__TTGLLightSetEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLLightSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLLightSetEditor*) (soff))->~G__TTGLLightSetEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLOverlayButton */
static int G__G__GL_558_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLOverlayButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLOverlayButton(
(TGLViewerBase*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGLOverlayButton(
(TGLViewerBase*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->ResetState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGLOverlayButton*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGLOverlayButton*) G__getstructoffset())->GetBackColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const TGLOverlayButton*) G__getstructoffset())->GetTextColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) 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__GL_558_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->SetSize((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__GL_558_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->SetAlphaValues((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__GL_558_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->SetBackColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->SetTextColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->Clicked((TGLViewerBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLOverlayButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLOverlayButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLOverlayButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLOverlayButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOverlayButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLOverlayButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_558_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLOverlayButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLOverlayButton G__TTGLOverlayButton;
static int G__G__GL_558_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLOverlayButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLOverlayButton*) (soff+(sizeof(TGLOverlayButton)*i)))->~G__TTGLOverlayButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLOverlayButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLOverlayButton*) (soff))->~G__TTGLOverlayButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLParametricEquationGL */
static int G__G__GL_562_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLParametricEquationGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLParametricEquationGL[n];
     } else {
       p = new((void*) gvp) TGLParametricEquationGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLParametricEquationGL;
     } else {
       p = new((void*) gvp) TGLParametricEquationGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLParametricEquationGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricEquationGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLParametricEquationGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLParametricEquationGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLParametricEquationGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricEquationGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLParametricEquationGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricEquationGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_562_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLParametricEquationGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLParametricEquationGL G__TTGLParametricEquationGL;
static int G__G__GL_562_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLParametricEquationGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLParametricEquationGL*) (soff+(sizeof(TGLParametricEquationGL)*i)))->~G__TTGLParametricEquationGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLParametricEquationGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLParametricEquationGL*) (soff))->~G__TTGLParametricEquationGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLParametricPlot */
static int G__G__GL_578_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLParametricPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLParametricPlot((TGLParametricEquation*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGLParametricPlot((TGLParametricEquation*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLParametricPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLParametricPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLParametricPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLParametricPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLParametricPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLParametricPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_578_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLParametricPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLParametricPlot G__TTGLParametricPlot;
static int G__G__GL_578_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLParametricPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLParametricPlot*) (soff+(sizeof(TGLParametricPlot)*i)))->~G__TTGLParametricPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLParametricPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLParametricPlot*) (soff))->~G__TTGLParametricPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPolyLine */
static int G__G__GL_586_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPolyLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPolyLine(*(TBuffer3D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLPolyLine(*(TBuffer3D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPolyLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPolyLine::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPolyLine::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPolyLine::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPolyLine::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPolyLine*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPolyLine::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPolyLine::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPolyLine::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_586_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPolyLine::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPolyLine G__TTGLPolyLine;
static int G__G__GL_586_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPolyLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPolyLine*) (soff+(sizeof(TGLPolyLine)*i)))->~G__TTGLPolyLine();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPolyLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPolyLine*) (soff))->~G__TTGLPolyLine();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPolyMarker */
static int G__G__GL_587_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPolyMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLPolyMarker(*(TBuffer3D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLPolyMarker(*(TBuffer3D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPolyMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPolyMarker::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPolyMarker::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPolyMarker::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPolyMarker::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPolyMarker*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPolyMarker::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPolyMarker::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPolyMarker::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_587_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPolyMarker::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPolyMarker G__TTGLPolyMarker;
static int G__G__GL_587_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLPolyMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPolyMarker*) (soff+(sizeof(TGLPolyMarker)*i)))->~G__TTGLPolyMarker();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPolyMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPolyMarker*) (soff))->~G__TTGLPolyMarker();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLPShapeObjEditor */
static int G__G__GL_591_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLPShapeObjEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeObjEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGLPShapeObjEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Pixel_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeObjEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLPShapeObjEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeObjEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLPShapeObjEditor(
(TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLPShapeObjEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLPShapeObjEditor((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 TGLPShapeObjEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLPShapeObjEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLPShapeObjEditor[n];
       } else {
         p = new((void*) gvp) TGLPShapeObjEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLPShapeObjEditor;
       } else {
         p = new((void*) gvp) TGLPShapeObjEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->SetCenter((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->SetScale((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->DoGeoButton();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->GetObjectData((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->GeoValueSet((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->CreateColorRadioButtons();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->CreateColorSliders();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->SetColorSlidersPos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGLPShapeObjEditor*) G__getstructoffset())->DrawSphere();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->SetRGBA((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TGLPShapeObjEditor*) G__getstructoffset())->GetRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->DoColorSlider((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->DoColorButton();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLPShapeObjEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeObjEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLPShapeObjEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLPShapeObjEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLPShapeObjEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeObjEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPShapeObjEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLPShapeObjEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_591_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLPShapeObjEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLPShapeObjEditor G__TTGLPShapeObjEditor;
static int G__G__GL_591_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[] (TGLPShapeObjEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLPShapeObjEditor*) (soff+(sizeof(TGLPShapeObjEditor)*i)))->~G__TTGLPShapeObjEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLPShapeObjEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLPShapeObjEditor*) (soff))->~G__TTGLPShapeObjEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLRotateManip */
static int G__G__GL_593_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRotateManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLRotateManip[n];
     } else {
       p = new((void*) gvp) TGLRotateManip[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLRotateManip;
     } else {
       p = new((void*) gvp) TGLRotateManip;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLRotateManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLRotateManip((TGLPhysicalShape*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLRotateManip((TGLPhysicalShape*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLRotateManip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRotateManip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLRotateManip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLRotateManip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLRotateManip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRotateManip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLRotateManip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLRotateManip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_593_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLRotateManip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_593_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLRotateManip* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLRotateManip(*(TGLRotateManip*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLRotateManip G__TTGLRotateManip;
static int G__G__GL_593_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLRotateManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLRotateManip*) (soff+(sizeof(TGLRotateManip)*i)))->~G__TTGLRotateManip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLRotateManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLRotateManip*) (soff))->~G__TTGLRotateManip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSAViewer */
static int G__G__GL_594_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSAViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSAViewer((TVirtualPad*) G__int(libp->para[0]), (TGLFormat*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLSAViewer((TVirtualPad*) G__int(libp->para[0]), (TGLFormat*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSAViewer((TVirtualPad*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLSAViewer((TVirtualPad*) 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__GLLN_TGLSAViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSAViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSAViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) G__int(libp->para[2]), (TGLFormat*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGLSAViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) G__int(libp->para[2]), (TGLFormat*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSAViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGLSAViewer(
(TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (TGedEditor*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLSAViewer((TGWindow*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLSAViewer((TGWindow*) G__int(libp->para[0]), (TVirtualPad*) 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__GLLN_TGLSAViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->Show();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->Close();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->DeleteMenuBar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->DisableCloseMenuEntries();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->EnableMenuBarHiding();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->DisableMenuBarHiding();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->MenuHidingTimeout();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->HandleMenuBarHiding((Event_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGLSAViewer*) G__getstructoffset())->ProcessFrameMessage((Long_t) G__int(libp->para[0]), (Long_t) G__int(libp->para[1])
, (Long_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSAViewer*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSAViewer*) G__getstructoffset())->GetLeftVerticalFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLSAViewer*) G__getstructoffset())->GetFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->ToggleEditObject();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->ToggleOrthoRotate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->ToggleOrthoDolly();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSAViewer::SetMenuHidingTimeout((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSAViewer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSAViewer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSAViewer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSAViewer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAViewer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSAViewer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSAViewer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSAViewer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_594_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSAViewer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSAViewer G__TTGLSAViewer;
static int G__G__GL_594_0_40(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[] (TGLSAViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSAViewer*) (soff+(sizeof(TGLSAViewer)*i)))->~G__TTGLSAViewer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSAViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSAViewer*) (soff))->~G__TTGLSAViewer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSAFrame */
static int G__G__GL_595_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSAFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSAFrame(*(TGLSAViewer*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLSAFrame(*(TGLSAViewer*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSAFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSAFrame((TGWindow*) G__int(libp->para[0]), *(TGLSAViewer*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGLSAFrame((TGWindow*) G__int(libp->para[0]), *(TGLSAViewer*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSAFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSAFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSAFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSAFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSAFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSAFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSAFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSAFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_595_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSAFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSAFrame G__TTGLSAFrame;
static int G__G__GL_595_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[] (TGLSAFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSAFrame*) (soff+(sizeof(TGLSAFrame)*i)))->~G__TTGLSAFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSAFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSAFrame*) (soff))->~G__TTGLSAFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLScaleManip */
static int G__G__GL_599_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLScaleManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLScaleManip[n];
     } else {
       p = new((void*) gvp) TGLScaleManip[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLScaleManip;
     } else {
       p = new((void*) gvp) TGLScaleManip;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLScaleManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLScaleManip((TGLPhysicalShape*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLScaleManip((TGLPhysicalShape*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLScaleManip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScaleManip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLScaleManip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLScaleManip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScaleManip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScaleManip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLScaleManip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScaleManip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_599_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLScaleManip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_599_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLScaleManip* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLScaleManip(*(TGLScaleManip*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLScaleManip G__TTGLScaleManip;
static int G__G__GL_599_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLScaleManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLScaleManip*) (soff+(sizeof(TGLScaleManip)*i)))->~G__TTGLScaleManip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLScaleManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLScaleManip*) (soff))->~G__TTGLScaleManip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLScene::TSceneInfo */
static int G__G__GL_637_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLScene::TSceneInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLScene::TSceneInfo((TGLViewerBase*) G__int(libp->para[0]), (TGLScene*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGLScene::TSceneInfo((TGLViewerBase*) G__int(libp->para[0]), (TGLScene*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLScene::TSceneInfo((TGLViewerBase*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGLScene::TSceneInfo((TGLViewerBase*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLScene::TSceneInfo[n];
       } else {
         p = new((void*) gvp) TGLScene::TSceneInfo[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TGLScene::TSceneInfo;
       } else {
         p = new((void*) gvp) TGLScene::TSceneInfo;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->ClearAfterRebuild();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->ClearAfterUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->Lodify(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->PreDraw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->PostDraw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->ResetDrawStats();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->UpdateDrawStats(*(TGLPhysicalShape*) libp->para[0].ref, (Short_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_637_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScene::TSceneInfo*) G__getstructoffset())->DumpDrawStats();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLScene::TSceneInfo G__TTGLScenecLcLTSceneInfo;
static int G__G__GL_637_0_13(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[] (TGLScene::TSceneInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLScene::TSceneInfo*) (soff+(sizeof(TGLScene::TSceneInfo)*i)))->~G__TTGLScenecLcLTSceneInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLScene::TSceneInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLScene::TSceneInfo*) (soff))->~G__TTGLScenecLcLTSceneInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLScenePad */
static int G__G__GL_647_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLScenePad* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLScenePad((TVirtualPad*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLScenePad((TVirtualPad*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLScenePad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGLScenePad*) G__getstructoffset())->GetPad());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScenePad*) G__getstructoffset())->AddHistoPhysical((TGLLogicalShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScenePad*) G__getstructoffset())->SubPadPaint((TVirtualPad*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScenePad*) G__getstructoffset())->PadPaintFromViewer((TGLViewer*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGLScenePad*) G__getstructoffset())->GetSmartRefresh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScenePad*) G__getstructoffset())->SetSmartRefresh((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLScenePad::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScenePad::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLScenePad::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLScenePad::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLScenePad*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScenePad::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLScenePad::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLScenePad::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_647_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLScenePad::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLScenePad G__TTGLScenePad;
static int G__G__GL_647_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLScenePad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLScenePad*) (soff+(sizeof(TGLScenePad)*i)))->~G__TTGLScenePad();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLScenePad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLScenePad*) (soff))->~G__TTGLScenePad();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSphere */
static int G__G__GL_658_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSphere* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSphere(*(TBuffer3DSphere*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGLSphere(*(TBuffer3DSphere*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSphere));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSphere::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSphere::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSphere::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSphere::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSphere*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSphere::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSphere::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSphere::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_658_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSphere::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSphere G__TTGLSphere;
static int G__G__GL_658_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLSphere*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSphere*) (soff+(sizeof(TGLSphere)*i)))->~G__TTGLSphere();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSphere*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSphere*) (soff))->~G__TTGLSphere();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLSurfacePainter */
static int G__G__GL_660_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLSurfacePainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLSurfacePainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLSurfacePainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLSurfacePainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSurfacePainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLSurfacePainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLSurfacePainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLSurfacePainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSurfacePainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSurfacePainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLSurfacePainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_660_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLSurfacePainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLSurfacePainter G__TTGLSurfacePainter;
static int G__G__GL_660_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLSurfacePainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLSurfacePainter*) (soff+(sizeof(TGLSurfacePainter)*i)))->~G__TTGLSurfacePainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLSurfacePainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLSurfacePainter*) (soff))->~G__TTGLSurfacePainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLTF3Painter */
static int G__G__GL_688_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTF3Painter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLTF3Painter(
(TF3*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TGLPlotCamera*) G__int(libp->para[2]), (TGLPlotCoordinates*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGLTF3Painter(
(TF3*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TGLPlotCamera*) G__int(libp->para[2]), (TGLPlotCoordinates*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLTF3Painter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTF3Painter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLTF3Painter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLTF3Painter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLTF3Painter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTF3Painter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTF3Painter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTF3Painter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_688_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTF3Painter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLTF3Painter G__TTGLTF3Painter;
static int G__G__GL_688_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLTF3Painter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLTF3Painter*) (soff+(sizeof(TGLTF3Painter)*i)))->~G__TTGLTF3Painter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLTF3Painter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLTF3Painter*) (soff))->~G__TTGLTF3Painter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLIsoPainter */
static int G__G__GL_691_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLIsoPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLIsoPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLIsoPainter(
(TH1*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLIsoPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLIsoPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLIsoPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLIsoPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLIsoPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLIsoPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLIsoPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLIsoPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_691_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLIsoPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLIsoPainter G__TTGLIsoPainter;
static int G__G__GL_691_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLIsoPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLIsoPainter*) (soff+(sizeof(TGLIsoPainter)*i)))->~G__TTGLIsoPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLIsoPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLIsoPainter*) (soff))->~G__TTGLIsoPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLTH3CompositionPainter */
static int G__G__GL_721_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTH3CompositionPainter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLTH3CompositionPainter(
(TGLTH3Composition*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGLTH3CompositionPainter(
(TGLTH3Composition*) G__int(libp->para[0]), (TGLPlotCamera*) G__int(libp->para[1])
, (TGLPlotCoordinates*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLTH3CompositionPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3CompositionPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLTH3CompositionPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLTH3CompositionPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLTH3CompositionPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3CompositionPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTH3CompositionPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTH3CompositionPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_721_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTH3CompositionPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLTH3CompositionPainter G__TTGLTH3CompositionPainter;
static int G__G__GL_721_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLTH3CompositionPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLTH3CompositionPainter*) (soff+(sizeof(TGLTH3CompositionPainter)*i)))->~G__TTGLTH3CompositionPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLTH3CompositionPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLTH3CompositionPainter*) (soff))->~G__TTGLTH3CompositionPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGLTransManip */
static int G__G__GL_728_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTransManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLTransManip[n];
     } else {
       p = new((void*) gvp) TGLTransManip[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGLTransManip;
     } else {
       p = new((void*) gvp) TGLTransManip;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTransManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGLTransManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGLTransManip((TGLPhysicalShape*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGLTransManip((TGLPhysicalShape*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTransManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGLTransManip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTransManip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGLTransManip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGLTransManip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGLTransManip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTransManip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTransManip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGLTransManip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_728_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGLTransManip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__GL_728_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGLTransManip* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGLTransManip(*(TGLTransManip*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TGLTransManip));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGLTransManip G__TTGLTransManip;
static int G__G__GL_728_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGLTransManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGLTransManip*) (soff+(sizeof(TGLTransManip)*i)))->~G__TTGLTransManip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGLTransManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGLTransManip*) (soff))->~G__TTGLTransManip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2GL */
static int G__G__GL_737_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2GL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2GL[n];
     } else {
       p = new((void*) gvp) TH2GL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2GL;
     } else {
       p = new((void*) gvp) TH2GL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TH2GL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2GL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2GL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2GL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2GL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2GL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2GL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2GL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2GL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_737_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2GL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2GL G__TTH2GL;
static int G__G__GL_737_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2GL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2GL*) (soff+(sizeof(TH2GL)*i)))->~G__TTH2GL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2GL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2GL*) (soff))->~G__TTH2GL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3GL */
static int G__G__GL_738_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3GL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3GL[n];
     } else {
       p = new((void*) gvp) TH3GL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3GL;
     } else {
       p = new((void*) gvp) TH3GL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TH3GL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3GL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3GL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3GL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3GL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3GL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3GL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3GL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3GL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_738_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3GL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3GL G__TTH3GL;
static int G__G__GL_738_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3GL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3GL*) (soff+(sizeof(TH3GL)*i)))->~G__TTH3GL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3GL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3GL*) (soff))->~G__TTH3GL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPointSet3DGL */
static int G__G__GL_739_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPointSet3DGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPointSet3DGL[n];
     } else {
       p = new((void*) gvp) TPointSet3DGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPointSet3DGL;
     } else {
       p = new((void*) gvp) TPointSet3DGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPointSet3DGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPointSet3DGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPointSet3DGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPointSet3DGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPointSet3DGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPointSet3DGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPointSet3DGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPointSet3DGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_739_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPointSet3DGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPointSet3DGL G__TTPointSet3DGL;
static int G__G__GL_739_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPointSet3DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPointSet3DGL*) (soff+(sizeof(TPointSet3DGL)*i)))->~G__TTPointSet3DGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPointSet3DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPointSet3DGL*) (soff))->~G__TTPointSet3DGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TX11GLManager */
static int G__G__GL_742_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TX11GLManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TX11GLManager[n];
     } else {
       p = new((void*) gvp) TX11GLManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TX11GLManager;
     } else {
       p = new((void*) gvp) TX11GLManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GLLN_TX11GLManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TX11GLManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TX11GLManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TX11GLManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TX11GLManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TX11GLManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TX11GLManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TX11GLManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TX11GLManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__GL_742_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TX11GLManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TX11GLManager G__TTX11GLManager;
static int G__G__GL_742_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TX11GLManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TX11GLManager*) (soff+(sizeof(TX11GLManager)*i)))->~G__TTX11GLManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TX11GLManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TX11GLManager*) (soff))->~G__TTX11GLManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TArcBall */

/* TGLBoundingBox */

/* TGLCamera */

/* TGLVector3 */

/* TGLVertex3 */

/* TGLLine3 */

/* TGLRect */

/* TGLPlane */

/* TGLMatrix */

/* TGLColor */

/* TGLColorSet */

/* TGLUtil */

/* TGLUtil::TColorLocker */

/* TGLUtil::TDrawQualityModifier */

/* TGLUtil::TDrawQualityScaler */

/* TGLSelectionBuffer */

/* TGLPlotCoordinates */

/* TGLQuadric */

/* Rgl */

/* TGLPhysicalShape */

/* TGLRnrCtx */

/* TGLSelectRecord */

/* TGLViewer */

/* TGLSceneBase */

/* TGLScene */

/* TGLLogicalShape */

/* TGLObject */

/* TGLManip */

/* TGLContext */

/* TGLFormat */

/* TGLPlotBox */

/* TGLPlotCamera */

/* TGL5DDataSet */

/* TGLBoxCut */

/* TGLTH3Slice */

/* TGLPlotPainter */

/* TGLPlot3D */

/* TF2GL */

/* TGL5DDataSetEditor */

/* TGLParametricEquation */

/* TGLTH3Composition */

/* TGLHistPainter */

/* TGLAdapter */

/* TGLOvlSelectRecord */

/* TGLOverlayElement */

/* TGLOverlayList */

/* TGLFontManager */

/* TGLFont */

/* TGLViewerBase */

/* TGLAnnotation */

/* TGLAutoRotator */

/* TGLText */

/* TGLAxis */

/* TGLAxisPainter */

/* TGLAxisPainterBox */

/* TGLBoxPainter */

/* TGLCameraGuide */

/* TGLCameraOverlay */

/* TGLPShapeRef */

/* TGLManipSet */

/* TGLClip */

/* TGLClipPlane */

/* TGLClipBox */

/* TGLClipSet */

/* TGLClipSetSubEditor */

/* TGLClipSetEditor */

/* TGLContextIdentity */

/* TGLWidget */

/* TGLCylinder */

/* TGLLockable */

/* TGLSceneInfo */

/* TGLStopwatch */

/* TGLSelectBuffer */

/* TGLSelectRecordBase */

/* TGLPerspectiveCamera */

/* TGLOrthoCamera */

/* TGLViewerEditor */

/* TGLLightSet */

/* TGLPShapeObj */

/* TGLOutput */

/* TGLEventHandler */

/* TGLFaderHelper */

/* TGLEmbeddedViewer */

/* TGLFaceSet */

/* TGLFBO */

/* TGLPadPainter */

/* TGLH2PolyPainter */

/* TGLLegoPainter */

/* TGLLightSetSubEditor */

/* TGLLightSetEditor */

/* TGLOverlayButton */

/* TGLParametricEquationGL */

/* TGLParametricPlot */

/* TGLPolyLine */

/* TGLPolyMarker */

/* TGLPShapeObjEditor */

/* TGLRotateManip */

/* TGLSAViewer */

/* TGLSAFrame */

/* TGLScaleManip */

/* TGLScene::TSceneInfo */

/* TGLScenePad */

/* TGLSphere */

/* TGLSurfacePainter */

/* TGLTF3Painter */

/* TGLIsoPainter */

/* TGLTH3CompositionPainter */

/* TGLTransManip */

/* TH2GL */

/* TH3GL */

/* TPointSet3DGL */

/* TX11GLManager */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__GL {
 public:
  G__Sizep2memfuncG__GL(): p(&G__Sizep2memfuncG__GL::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__GL::*p)();
};

size_t G__get_sizep2memfuncG__GL()
{
  G__Sizep2memfuncG__GL 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__GL() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLVector3))) {
     TGLVector3 *G__Lderived;
     G__Lderived=(TGLVector3*)0x1000;
     {
       TGLVertex3 *G__Lpbase=(TGLVertex3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLVector3),G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord))) {
     TGLSelectRecord *G__Lderived;
     G__Lderived=(TGLSelectRecord*)0x1000;
     {
       TGLSelectRecordBase *G__Lpbase=(TGLSelectRecordBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord),G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLViewer))) {
     TGLViewer *G__Lderived;
     G__Lderived=(TGLViewer*)0x1000;
     {
       TVirtualViewer3D *G__Lpbase=(TVirtualViewer3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer),G__get_linked_tagnum(&G__G__GLLN_TVirtualViewer3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLViewerBase *G__Lpbase=(TGLViewerBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer),G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase))) {
     TGLSceneBase *G__Lderived;
     G__Lderived=(TGLSceneBase*)0x1000;
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLScene))) {
     TGLScene *G__Lderived;
     G__Lderived=(TGLScene*)0x1000;
     {
       TGLSceneBase *G__Lpbase=(TGLSceneBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScene),G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScene),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLObject))) {
     TGLObject *G__Lderived;
     G__Lderived=(TGLObject*)0x1000;
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLObject),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TVirtualViewer3D))) {
     TVirtualViewer3D *G__Lderived;
     G__Lderived=(TVirtualViewer3D*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TVirtualViewer3D),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLManip))) {
     TGLManip *G__Lderived;
     G__Lderived=(TGLManip*)0x1000;
     {
       TVirtualGLManip *G__Lpbase=(TVirtualGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManip),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLManip),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet))) {
     TGL5DDataSet *G__Lderived;
     G__Lderived=(TGL5DDataSet*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice))) {
     TGLTH3Slice *G__Lderived;
     G__Lderived=(TGLTH3Slice*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter))) {
     TGLPlotPainter *G__Lderived;
     G__Lderived=(TGLPlotPainter*)0x1000;
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D))) {
     TGLPlot3D *G__Lderived;
     G__Lderived=(TGLPlot3D*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D),G__get_linked_tagnum(&G__G__GLLN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TF2GL))) {
     TF2GL *G__Lderived;
     G__Lderived=(TF2GL*)0x1000;
     {
       TGLPlot3D *G__Lpbase=(TGLPlot3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TF2GL),G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TF2GL),G__get_linked_tagnum(&G__G__GLLN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TF2GL),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor))) {
     TGL5DDataSetEditor *G__Lderived;
     G__Lderived=(TGL5DDataSetEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation))) {
     TGLParametricEquation *G__Lderived;
     G__Lderived=(TGLParametricEquation*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition))) {
     TGLTH3Composition *G__Lderived;
     G__Lderived=(TGLTH3Composition*)0x1000;
     {
       TH3C *G__Lpbase=(TH3C*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TH3C),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayC *G__Lpbase=(TArrayC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TArrayC),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),G__get_linked_tagnum(&G__G__GLLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter))) {
     TGLHistPainter *G__Lderived;
     G__Lderived=(TGLHistPainter*)0x1000;
     {
       TVirtualHistPainter *G__Lpbase=(TVirtualHistPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualHistPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLAdapter))) {
     TGLAdapter *G__Lderived;
     G__Lderived=(TGLAdapter*)0x1000;
     {
       TGLPaintDevice *G__Lpbase=(TGLPaintDevice*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAdapter),G__get_linked_tagnum(&G__G__GLLN_TGLPaintDevice),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord))) {
     TGLOvlSelectRecord *G__Lderived;
     G__Lderived=(TGLOvlSelectRecord*)0x1000;
     {
       TGLSelectRecordBase *G__Lpbase=(TGLSelectRecordBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord),G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase))) {
     TGLViewerBase *G__Lderived;
     G__Lderived=(TGLViewerBase*)0x1000;
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation))) {
     TGLAnnotation *G__Lderived;
     G__Lderived=(TGLAnnotation*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation),G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator))) {
     TGLAutoRotator *G__Lderived;
     G__Lderived=(TGLAutoRotator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLText))) {
     TGLText *G__Lderived;
     G__Lderived=(TGLText*)0x1000;
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLText),G__get_linked_tagnum(&G__G__GLLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLAxis))) {
     TGLAxis *G__Lderived;
     G__Lderived=(TGLAxis*)0x1000;
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxis),G__get_linked_tagnum(&G__G__GLLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttText *G__Lpbase=(TAttText*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxis),G__get_linked_tagnum(&G__G__GLLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainterBox))) {
     TGLAxisPainterBox *G__Lderived;
     G__Lderived=(TGLAxisPainterBox*)0x1000;
     {
       TGLAxisPainter *G__Lpbase=(TGLAxisPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainterBox),G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter))) {
     TGLBoxPainter *G__Lderived;
     G__Lderived=(TGLBoxPainter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide))) {
     TGLCameraGuide *G__Lderived;
     G__Lderived=(TGLCameraGuide*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide),G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay))) {
     TGLCameraOverlay *G__Lderived;
     G__Lderived=(TGLCameraOverlay*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay),G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLManipSet))) {
     TGLManipSet *G__Lderived;
     G__Lderived=(TGLManipSet*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManipSet),G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLPShapeRef *G__Lpbase=(TGLPShapeRef*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManipSet),G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLClip))) {
     TGLClip *G__Lderived;
     G__Lderived=(TGLClip*)0x1000;
     {
       TGLPhysicalShape *G__Lpbase=(TGLPhysicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClip),G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane))) {
     TGLClipPlane *G__Lderived;
     G__Lderived=(TGLClipPlane*)0x1000;
     {
       TGLClip *G__Lpbase=(TGLClip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane),G__get_linked_tagnum(&G__G__GLLN_TGLClip),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLPhysicalShape *G__Lpbase=(TGLPhysicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane),G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLClipBox))) {
     TGLClipBox *G__Lderived;
     G__Lderived=(TGLClipBox*)0x1000;
     {
       TGLClip *G__Lpbase=(TGLClip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipBox),G__get_linked_tagnum(&G__G__GLLN_TGLClip),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLPhysicalShape *G__Lpbase=(TGLPhysicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipBox),G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLClipSet))) {
     TGLClipSet *G__Lderived;
     G__Lderived=(TGLClipSet*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSet),G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor))) {
     TGLClipSetSubEditor *G__Lderived;
     G__Lderived=(TGLClipSetSubEditor*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor))) {
     TGLClipSetEditor *G__Lderived;
     G__Lderived=(TGLClipSetEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLWidget))) {
     TGLWidget *G__Lderived;
     G__Lderived=(TGLWidget*)0x1000;
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLPaintDevice *G__Lpbase=(TGLPaintDevice*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget),G__get_linked_tagnum(&G__G__GLLN_TGLPaintDevice),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLCylinder))) {
     TGLCylinder *G__Lderived;
     G__Lderived=(TGLCylinder*)0x1000;
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCylinder),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera))) {
     TGLPerspectiveCamera *G__Lderived;
     G__Lderived=(TGLPerspectiveCamera*)0x1000;
     {
       TGLCamera *G__Lpbase=(TGLCamera*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera),G__get_linked_tagnum(&G__G__GLLN_TGLCamera),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera))) {
     TGLOrthoCamera *G__Lderived;
     G__Lderived=(TGLOrthoCamera*)0x1000;
     {
       TGLCamera *G__Lpbase=(TGLCamera*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),G__get_linked_tagnum(&G__G__GLLN_TGLCamera),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor))) {
     TGLViewerEditor *G__Lderived;
     G__Lderived=(TGLViewerEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLLightSet))) {
     TGLLightSet *G__Lderived;
     G__Lderived=(TGLLightSet*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSet),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj))) {
     TGLPShapeObj *G__Lderived;
     G__Lderived=(TGLPShapeObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler))) {
     TGLEventHandler *G__Lderived;
     G__Lderived=(TGLEventHandler*)0x1000;
     {
       TGEventHandler *G__Lpbase=(TGEventHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler),G__get_linked_tagnum(&G__G__GLLN_TGEventHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer))) {
     TGLEmbeddedViewer *G__Lderived;
     G__Lderived=(TGLEmbeddedViewer*)0x1000;
     {
       TGLViewer *G__Lpbase=(TGLViewer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer),G__get_linked_tagnum(&G__G__GLLN_TGLViewer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualViewer3D *G__Lpbase=(TVirtualViewer3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer),G__get_linked_tagnum(&G__G__GLLN_TVirtualViewer3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLViewerBase *G__Lpbase=(TGLViewerBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer),G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet))) {
     TGLFaceSet *G__Lderived;
     G__Lderived=(TGLFaceSet*)0x1000;
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter))) {
     TGLPadPainter *G__Lderived;
     G__Lderived=(TGLPadPainter*)0x1000;
     {
       TVirtualPadPainter *G__Lpbase=(TVirtualPadPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualPadPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter))) {
     TGLH2PolyPainter *G__Lderived;
     G__Lderived=(TGLH2PolyPainter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter))) {
     TGLLegoPainter *G__Lderived;
     G__Lderived=(TGLLegoPainter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor))) {
     TGLLightSetSubEditor *G__Lderived;
     G__Lderived=(TGLLightSetSubEditor*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor))) {
     TGLLightSetEditor *G__Lderived;
     G__Lderived=(TGLLightSetEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton))) {
     TGLOverlayButton *G__Lderived;
     G__Lderived=(TGLOverlayButton*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton),G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL))) {
     TGLParametricEquationGL *G__Lderived;
     G__Lderived=(TGLParametricEquationGL*)0x1000;
     {
       TGLPlot3D *G__Lpbase=(TGLPlot3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL),G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL),G__get_linked_tagnum(&G__G__GLLN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot))) {
     TGLParametricPlot *G__Lderived;
     G__Lderived=(TGLParametricPlot*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPolyLine))) {
     TGLPolyLine *G__Lderived;
     G__Lderived=(TGLPolyLine*)0x1000;
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPolyLine),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPolyMarker))) {
     TGLPolyMarker *G__Lderived;
     G__Lderived=(TGLPolyMarker*)0x1000;
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPolyMarker),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor))) {
     TGLPShapeObjEditor *G__Lderived;
     G__Lderived=(TGLPShapeObjEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLPShapeRef *G__Lpbase=(TGLPShapeRef*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor),G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip))) {
     TGLRotateManip *G__Lderived;
     G__Lderived=(TGLRotateManip*)0x1000;
     {
       TGLManip *G__Lpbase=(TGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip),G__get_linked_tagnum(&G__G__GLLN_TGLManip),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLManip *G__Lpbase=(TVirtualGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLManip),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer))) {
     TGLSAViewer *G__Lderived;
     G__Lderived=(TGLSAViewer*)0x1000;
     {
       TGLViewer *G__Lpbase=(TGLViewer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),G__get_linked_tagnum(&G__G__GLLN_TGLViewer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualViewer3D *G__Lpbase=(TVirtualViewer3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),G__get_linked_tagnum(&G__G__GLLN_TVirtualViewer3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLViewerBase *G__Lpbase=(TGLViewerBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame))) {
     TGLSAFrame *G__Lderived;
     G__Lderived=(TGLSAFrame*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),G__get_linked_tagnum(&G__G__GLLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip))) {
     TGLScaleManip *G__Lderived;
     G__Lderived=(TGLScaleManip*)0x1000;
     {
       TGLManip *G__Lpbase=(TGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip),G__get_linked_tagnum(&G__G__GLLN_TGLManip),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLManip *G__Lpbase=(TVirtualGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLManip),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo))) {
     TGLScene::TSceneInfo *G__Lderived;
     G__Lderived=(TGLScene::TSceneInfo*)0x1000;
     {
       TGLSceneInfo *G__Lpbase=(TGLSceneInfo*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo),G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad))) {
     TGLScenePad *G__Lderived;
     G__Lderived=(TGLScenePad*)0x1000;
     {
       TVirtualViewer3D *G__Lpbase=(TVirtualViewer3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad),G__get_linked_tagnum(&G__G__GLLN_TVirtualViewer3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLScene *G__Lpbase=(TGLScene*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad),G__get_linked_tagnum(&G__G__GLLN_TGLScene),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLSceneBase *G__Lpbase=(TGLSceneBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad),G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLockable *G__Lpbase=(TGLLockable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad),G__get_linked_tagnum(&G__G__GLLN_TGLLockable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLSphere))) {
     TGLSphere *G__Lderived;
     G__Lderived=(TGLSphere*)0x1000;
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSphere),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter))) {
     TGLSurfacePainter *G__Lderived;
     G__Lderived=(TGLSurfacePainter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter))) {
     TGLTF3Painter *G__Lderived;
     G__Lderived=(TGLTF3Painter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter))) {
     TGLIsoPainter *G__Lderived;
     G__Lderived=(TGLIsoPainter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TArrayC))) {
     TArrayC *G__Lderived;
     G__Lderived=(TArrayC*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TArrayC),G__get_linked_tagnum(&G__G__GLLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TH3C))) {
     TH3C *G__Lderived;
     G__Lderived=(TH3C*)0x1000;
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayC *G__Lpbase=(TArrayC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TArrayC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3C),G__get_linked_tagnum(&G__G__GLLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter))) {
     TGLTH3CompositionPainter *G__Lderived;
     G__Lderived=(TGLTH3CompositionPainter*)0x1000;
     {
       TGLPlotPainter *G__Lpbase=(TGLPlotPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter),G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLPainter *G__Lpbase=(TVirtualGLPainter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLPainter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TGLTransManip))) {
     TGLTransManip *G__Lderived;
     G__Lderived=(TGLTransManip*)0x1000;
     {
       TGLManip *G__Lpbase=(TGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTransManip),G__get_linked_tagnum(&G__G__GLLN_TGLManip),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualGLManip *G__Lpbase=(TVirtualGLManip*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTransManip),G__get_linked_tagnum(&G__G__GLLN_TVirtualGLManip),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TH2GL))) {
     TH2GL *G__Lderived;
     G__Lderived=(TH2GL*)0x1000;
     {
       TGLPlot3D *G__Lpbase=(TGLPlot3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH2GL),G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH2GL),G__get_linked_tagnum(&G__G__GLLN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH2GL),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TH3GL))) {
     TH3GL *G__Lderived;
     G__Lderived=(TH3GL*)0x1000;
     {
       TGLPlot3D *G__Lpbase=(TGLPlot3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3GL),G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3GL),G__get_linked_tagnum(&G__G__GLLN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TH3GL),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL))) {
     TPointSet3DGL *G__Lderived;
     G__Lderived=(TPointSet3DGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL),G__get_linked_tagnum(&G__G__GLLN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL),G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GLLN_TX11GLManager))) {
     TX11GLManager *G__Lderived;
     G__Lderived=(TX11GLManager*)0x1000;
     {
       TGLManager *G__Lpbase=(TGLManager*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TX11GLManager),G__get_linked_tagnum(&G__G__GLLN_TGLManager),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TX11GLManager),G__get_linked_tagnum(&G__G__GLLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__GLLN_TX11GLManager),G__get_linked_tagnum(&G__G__GLLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__GL() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   G__search_typename2("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("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("Font_t",115,-1,0,-1);
   G__setnewtype(-1,"Font 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__GLLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLPlane>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TGLPlaneSet_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Bool_t,TGLLine3>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEboolcOTGLLine3gR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Bool_t,TGLVertex3>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEboolcOTGLVertex3gR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UChar_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned char>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Int_t,Int_t>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BinRange_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR),0,G__get_linked_tagnum(&G__G__GLLN_Rgl));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,Double_t>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Range_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),0,G__get_linked_tagnum(&G__G__GLLN_Rgl));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__GLLN_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__GLLN_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__GLLN_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__GLLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Pixel_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixel value",0);
   G__search_typename2("TGL2DArray<Double_t>",117,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLOverlayElement*>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FontSizeVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,Int_t>",117,G__get_linked_tagnum(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,int>",117,G__get_linked_tagnum(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,int,less<TGLFont> >",117,G__get_linked_tagnum(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FontMap_t",117,G__get_linked_tagnum(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FontMap_i",117,G__get_linked_tagnum(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<const TGLFont*>",117,G__get_linked_tagnum(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FontList_t",117,G__get_linked_tagnum(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FontList_i",117,G__get_linked_tagnum(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FontList_ci",117,G__get_linked_tagnum(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Float_t>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEfloatcOfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Lab_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEfloatcOfloatgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   G__setnewtype(-1,"label <pos, value> pair",0);
   G__search_typename2("vector<Lab_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,float> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("LabVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Int_t>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEfloatcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TM_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEfloatcOintgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   G__setnewtype(-1,"tick-mark <pos, order> pair",0);
   G__search_typename2("vector<TM_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,int> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   G__setnewtype(-1,"vector od tick lines",0);
   G__search_typename2("pair<UInt_t,Int_t>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DLRange_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcOintgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<DLRange_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<pair<unsigned int,int> >",117,G__get_linked_tagnum(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DLTrash_t",117,G__get_linked_tagnum(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DLTrashIt_t",117,G__get_linked_tagnum(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLContext*>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLContextmUcOallocatorlETGLContextmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CtxList_t",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLContextmUcOallocatorlETGLContextmUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLSceneInfo*>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SceneInfoList_t",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SceneInfoList_i",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLSceneInfo*>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SceneInfoVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SceneInfoVec_i",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLOverlayElement*>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("OverlayElmVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("OverlayElmVec_i",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SubRender_foo",97,-1,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__setnewtype(-1,"void (TGLSceneBase::* SubRender_foo) (TGLRnrCtx &);",0);
   G__search_typename2("list<TGLColorSet*,std::allocator<TGLColorSet*> >",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLColorSet*>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("lpTGLColorSet_t",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TPoint>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETPointcOallocatorlETPointgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETPointcOallocatorlETPointgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<MeshPatch_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Rgl::Pad::MeshPatch_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Rgl::Pad::Tesselation_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> > >",117,G__get_linked_tagnum(&G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CIter_t",117,G__get_linked_tagnum(&G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Rgl::Range_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CosSin_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),0,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<CosSin_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ParametricEquation_t",89,-1,0,-1);
   G__setnewtype(-1,"void (*ParametricEquation_t)(TGLVertex3 &, Double_t u, Double_t v);",0);
   G__search_typename2("Ptr_t",117,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETF2gR),0,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Painter_t",117,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETGLHistPaintergR),0,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TGL2DArray<Vertex_t>",117,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylETGLParametricPlotcLcLVertex_tgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLParametricPlot::Vertex_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLViewerBase*>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ViewerList_t",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ViewerList_i",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TObject*,TGLLogicalShape*>",117,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TObject*,TGLLogicalShape*,less<TObject*> >",117,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("LogicalShapeMap_t",117,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("LogicalShapeMapValueType_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlETObjectmUcOTGLLogicalShapemUgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("LogicalShapeMapIt_t",117,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("LogicalShapeMapCIt_t",117,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,TGLPhysicalShape*>",117,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,TGLPhysicalShape*>",117,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,TGLPhysicalShape*,less<unsigned int> >",117,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PhysicalShapeMap_t",117,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PhysicalShapeMapValueType_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcOTGLPhysicalShapemUgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PhysicalShapeMapIt_t",117,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PhysicalShapeMapCIt_t",117,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DrawElement_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLScene::DrawElement_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DrawElementVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DrawElementVec_i",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DrawElement_t*>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLScene::DrawElement_t*>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DrawElementPtrVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DrawElementPtrVec_i",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TGLPhysicalShape*>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ShapeVec_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ShapeVec_i",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TClass*,UInt_t>",117,G__get_linked_tagnum(&G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TClass*,unsigned int>",117,G__get_linked_tagnum(&G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TClass*,unsigned int,less<TClass*> >",117,G__get_linked_tagnum(&G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,RootCsg::TBaseMesh*>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CSPart_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLScenePad));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<CSPart_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned int,RootCsg::TBaseMesh*> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,UInt_t*>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcOunsignedsPintmUgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RawRecord_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEunsignedsPintcOunsignedsPintmUgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RawRecord_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned int,unsigned int*> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vRawRecord_t",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLVertex3>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLVertex3cOallocatorlETGLVertex3gRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLVertex3cOallocatorlETGLVertex3gRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLVertex3cOallocatorlETGLVertex3gRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLVertex3cOallocatorlETGLVertex3gRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLVertex3cOallocatorlETGLVertex3gRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TGL2DArray<std::pair<TGLVector3,TGLVector3> >",117,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylEpairlETGLVector3cOTGLVector3gRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<TGLVector3,TGLVector3> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLVector3>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLVector3cOallocatorlETGLVector3gRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLVector3cOallocatorlETGLVector3gRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLVector3cOallocatorlETGLVector3gRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlETGLVector3cOallocatorlETGLVector3gRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLVector3cOallocatorlETGLVector3gRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Projection_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLSurfacePainter::Projection_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Mesh_t",117,G__get_linked_tagnum(&G__G__GLLN_RglcLcLMccLcLTIsoMeshlEfloatgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Mesh_t>",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Rgl::Mc::TIsoMesh<float> >",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MeshList_t",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MeshIter_t",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ConstMeshIter_t",117,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__GLLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__GLLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<const TH3*,ETH3BinShape>",117,G__get_linked_tagnum(&G__G__GLLN_pairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegR),0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TH3Pair_t",117,G__get_linked_tagnum(&G__G__GLLN_pairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegR),0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH3Pair_t>",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<const TH3*,TGLTH3Composition::ETH3BinShape> >",117,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TGLContext*>",117,G__get_linked_tagnum(&G__G__GLLN_setlETGLContextmUcOlesslETGLContextmUgRcOallocatorlETGLContextmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TGLContext*,less<TGLContext*> >",117,G__get_linked_tagnum(&G__G__GLLN_setlETGLContextmUcOlesslETGLContextmUgRcOallocatorlETGLContextmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TArcBall */
static void G__setup_memvarTArcBall(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TArcBall));
   { TArcBall *p; p=(TArcBall*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fThisRot[9]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastRot[9]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTransform[16]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStVec[3]=",0,"Saved click vector");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnVec[3]=",0,"Saved drag vector");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdjustWidth=",0,"Mouse bounds width");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdjustHeight=",0,"Mouse bounds 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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLBoundingBox */
static void G__setup_memvarTGLBoundingBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   { TGLBoundingBox *p; p=(TGLBoundingBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"fVertex[8]=",0,"! the 8 bounding box vertices");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVolume=",0,"! box volume - cached for speed");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDiagonal=",0,"! max box diagonal - cached for speed");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,4,"fAxes[3]=",0,"! box axes in global frame - cached for speed");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,4,"fAxesNorm[3]=",0,"! normalised box axes in global frame - cached for speed");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceLowX=%lldLL",(long long)TGLBoundingBox::kFaceLowX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceHighX=%lldLL",(long long)TGLBoundingBox::kFaceHighX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceLowY=%lldLL",(long long)TGLBoundingBox::kFaceLowY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceHighY=%lldLL",(long long)TGLBoundingBox::kFaceHighY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceLowZ=%lldLL",(long long)TGLBoundingBox::kFaceLowZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceHighZ=%lldLL",(long long)TGLBoundingBox::kFaceHighZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBoxcLcLEFace),-1,-2,1,G__FastAllocString(2048).Format("kFaceCount=%lldLL",(long long)TGLBoundingBox::kFaceCount).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLCamera */
static void G__setup_memvarTGLCamera(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCamera));
   { TGLCamera *p; p=(TGLCamera*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kNear=%lldLL",(long long)TGLCamera::kNear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kLeft=%lldLL",(long long)TGLCamera::kLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kRight=%lldLL",(long long)TGLCamera::kRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kTop=%lldLL",(long long)TGLCamera::kTop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kBottom=%lldLL",(long long)TGLCamera::kBottom).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kFar=%lldLL",(long long)TGLCamera::kFar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameracLcLEFrustumPlane),-1,-2,1,G__FastAllocString(2048).Format("kPlanesPerFrustum=%lldLL",(long long)TGLCamera::kPlanesPerFrustum).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,4,"fPreviousInterestBox=",0,"! previous interest box (DEBUG)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,4,"fInterestFrustum=",0,"! frustum basis of current interest box - NOT a true BB! (DEBUG)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,4,"fInterestFrustumAsBox=",0,"! frustum basis (as box) of current interest box (DEBUG)");
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgInterestBoxExpansion=",0,"! expansion c.f. aligned current frustum box");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,2,"fCamBase=",0,"! tranformation to center and rotation from up to x vector");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,2,"fCamTrans=",0,"! transformation relative to fCamTrans");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fExternalCenter=",0,"! use external center insead of scene center");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFixDefCenter=",0,"! use fixed default center");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fExtCenter=",0,"! external camera center");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fDefCenter=",0,"! deafult camera center");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fFDCenter=",0,"! fixed deafult camera center");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fCenter=",0,"! current camera center");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNearClip=",0,"! last applied near-clip");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFarClip=",0,"! last applied far-clip");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDollyDefault=",0,"! default distnce from viewing centre");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDollyDistance=",0,"! unit distance for camera movement in fwd/bck direction");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVAxisMinAngle=",0,"! minimal allowed angle between up and fCamTrans Z vector");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCacheDirty=",0,"! cached items dirty?");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTimeStamp=",0,"! timestamp");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,2,"fLastNoPickProjM=",0,"! no-pick projection matrix (cached)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,2,"fProjM=",0,"! projection matrix        (cached)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,2,"fModVM=",0,"! modelView matrix         (cached)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,2,"fClipM=",0,"! object space clip matrix (cached)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlane),-1,-1,2,"fFrustumPlanes[6]=",0,"! frustum planes           (cached)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLRect),-1,-1,2,"fViewport=",0,"! viewport (GL coords - origin bottom left)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,2,"fInterestBox=",0,"! the interest box - created in UpdateInterest()");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLargestSeen=",0,"! largest box diagonal seen in OfInterest() - used when");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgDollyDeltaSens=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLVector3 */
static void G__setup_memvarTGLVector3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLVector3));
   { TGLVector3 *p; p=(TGLVector3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLVertex3 */
static void G__setup_memvarTGLVertex3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLVertex3));
   { TGLVertex3 *p; p=(TGLVertex3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVals[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLine3 */
static void G__setup_memvarTGLLine3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLine3));
   { TGLLine3 *p; p=(TGLLine3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"fVertex=",0,"! Start vertex of line");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,4,"fVector=",0,"! Vector of line from fVertex");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLRect */
static void G__setup_memvarTGLRect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRect));
   { TGLRect *p; p=(TGLRect*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fY=",0,"! Corner");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHeight=",0,"! Positive width/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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPlane */
static void G__setup_memvarTGLPlane(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   { TGLPlane *p; p=(TGLPlane*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVals[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLMatrix */
static void G__setup_memvarTGLMatrix(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   { TGLMatrix *p; p=(TGLMatrix*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVals[16]=",0,"Column MAJOR as per OGL");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLColor */
static void G__setup_memvarTGLColor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLColor));
   { TGLColor *p; p=(TGLColor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fRGBA[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLColorSet */
static void G__setup_memvarTGLColorSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLColorSet));
   { TGLColorSet *p; p=(TGLColorSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColor),-1,-1,2,"fBackground=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColor),-1,-1,2,"fForeground=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColor),-1,-1,2,"fOutline=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColor),-1,-1,2,"fMarkup=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColor),-1,-1,2,"fSelection[5]=",0,"Colors for shape-selection-levels");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLUtil */
static void G__setup_memvarTGLUtil(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtil));
   { TGLUtil *p; p=(TGLUtil*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgDefaultDrawQuality=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgDrawQuality=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgColorLockCount=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,4,"fgPointSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,4,"fgLineWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,4,"fgPointSizeScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,4,"fgLineWidthScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLELineHeadShape),-1,-2,1,G__FastAllocString(2048).Format("kLineHeadNone=%lldLL",(long long)TGLUtil::kLineHeadNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLELineHeadShape),-1,-2,1,G__FastAllocString(2048).Format("kLineHeadArrow=%lldLL",(long long)TGLUtil::kLineHeadArrow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLELineHeadShape),-1,-2,1,G__FastAllocString(2048).Format("kLineHeadBox=%lldLL",(long long)TGLUtil::kLineHeadBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLEAxesType),-1,-2,1,G__FastAllocString(2048).Format("kAxesNone=%lldLL",(long long)TGLUtil::kAxesNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLEAxesType),-1,-2,1,G__FastAllocString(2048).Format("kAxesEdge=%lldLL",(long long)TGLUtil::kAxesEdge).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLEAxesType),-1,-2,1,G__FastAllocString(2048).Format("kAxesOrigin=%lldLL",(long long)TGLUtil::kAxesOrigin).data(),0,(char*)NULL);
   G__memvar_setup((void*)(&TGLUtil::fgRed),98,0,1,-1,G__defined_typename("UChar_t"),-2,1,"fgRed[4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLUtil::fgGreen),98,0,1,-1,G__defined_typename("UChar_t"),-2,1,"fgGreen[4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLUtil::fgBlue),98,0,1,-1,G__defined_typename("UChar_t"),-2,1,"fgBlue[4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLUtil::fgYellow),98,0,1,-1,G__defined_typename("UChar_t"),-2,1,"fgYellow[4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLUtil::fgWhite),98,0,1,-1,G__defined_typename("UChar_t"),-2,1,"fgWhite[4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLUtil::fgGrey),98,0,1,-1,G__defined_typename("UChar_t"),-2,1,"fgGrey[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLUtil::TColorLocker */
static void G__setup_memvarTGLUtilcLcLTColorLocker(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker));
   { TGLUtil::TColorLocker *p; p=(TGLUtil::TColorLocker*)0x1000; if (p) { }
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLUtil::TDrawQualityModifier */
static void G__setup_memvarTGLUtilcLcLTDrawQualityModifier(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier));
   { TGLUtil::TDrawQualityModifier *p; p=(TGLUtil::TDrawQualityModifier*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOldQuality=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLUtil::TDrawQualityScaler */
static void G__setup_memvarTGLUtilcLcLTDrawQualityScaler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler));
   { TGLUtil::TDrawQualityScaler *p; p=(TGLUtil::TDrawQualityScaler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOldQuality=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSelectionBuffer */
static void G__setup_memvarTGLSelectionBuffer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer));
   { TGLSelectionBuffer *p; p=(TGLSelectionBuffer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),G__defined_typename("vector<UChar_t>"),-1,4,"fBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPlotCoordinates */
static void G__setup_memvarTGLPlotCoordinates(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates));
   { TGLPlotCoordinates *p; p=(TGLPlotCoordinates*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_EGLCoordType),-1,-1,4,"fCoordType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR),G__defined_typename("BinRange_t"),-1,4,"fXBins=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR),G__defined_typename("BinRange_t"),-1,4,"fYBins=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR),G__defined_typename("BinRange_t"),-1,4,"fZBins=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fYScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fXRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fYRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fZRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fXRangeScaled=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fYRangeScaled=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fZRangeScaled=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fXLog=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fYLog=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fZLog=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fModified=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFactor=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLQuadric */
static void G__setup_memvarTGLQuadric(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLQuadric));
   { TGLQuadric *p; p=(TGLQuadric*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_GLUquadric),-1,-1,4,"fQuad=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* Rgl */
static void G__setup_memvarRgl(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_Rgl));
   {
   G__memvar_setup((void*)(&Rgl::gRedEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gRedEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gGreenEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gGreenEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gBlueEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gBlueEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gOrangeEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gOrangeEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gWhiteEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gWhiteEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gGrayEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gGrayEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gNullEmission),102,0,1,-1,G__defined_typename("Float_t"),-1,1,"gNullEmission[]=",0,(char*)NULL);
   G__memvar_setup((void*)(&Rgl::gH2PolyScaleXY),100,0,1,-1,G__defined_typename("Double_t"),-1,1,"gH2PolyScaleXY=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPhysicalShape */
static void G__setup_memvarTGLPhysicalShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape));
   { TGLPhysicalShape *p; p=(TGLPhysicalShape*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kTranslateX=%lldLL",(long long)TGLPhysicalShape::kTranslateX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kTranslateY=%lldLL",(long long)TGLPhysicalShape::kTranslateY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kTranslateZ=%lldLL",(long long)TGLPhysicalShape::kTranslateZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kTranslateAll=%lldLL",(long long)TGLPhysicalShape::kTranslateAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kScaleX=%lldLL",(long long)TGLPhysicalShape::kScaleX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kScaleY=%lldLL",(long long)TGLPhysicalShape::kScaleY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kScaleZ=%lldLL",(long long)TGLPhysicalShape::kScaleZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kScaleAll=%lldLL",(long long)TGLPhysicalShape::kScaleAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kRotateX=%lldLL",(long long)TGLPhysicalShape::kRotateX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kRotateY=%lldLL",(long long)TGLPhysicalShape::kRotateY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kRotateZ=%lldLL",(long long)TGLPhysicalShape::kRotateZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kRotateAll=%lldLL",(long long)TGLPhysicalShape::kRotateAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kManipAll=%lldLL",(long long)TGLPhysicalShape::kManipAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape),-1,-1,4,"fLogicalShape=",0,"! the associated logical shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,4,"fNextPhysical=",0,"! pointer to next replica");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef),-1,-1,4,"fFirstPSRef=",0,"! pointer to first reference");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fID=",0,"! unique physical ID within containing scene");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLMatrix),-1,-1,4,"fTransform=",0,"! transform (placement) of physical instance");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,4,"fBoundingBox=",0,"! bounding box of the physical (transformed)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fColor[17]=",0,"! GL color array");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fSelected=",0,"! selected state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInvertedWind=",0,"! face winding TODO: can get directly from fTransform?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fModified=",0,"! has been modified - retain across scene rebuilds");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip),-1,-1,4,"fManip=",0,"! permitted manipulation bitflags - see EManip");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLRnrCtx */
static void G__setup_memvarTGLRnrCtx(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx));
   { TGLRnrCtx *p; p=(TGLRnrCtx*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kStyleUndef=%lldLL",(long long)TGLRnrCtx::kStyleUndef).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kFill=%lldLL",(long long)TGLRnrCtx::kFill).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kOutline=%lldLL",(long long)TGLRnrCtx::kOutline).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEStyle),-1,-2,1,G__FastAllocString(2048).Format("kWireFrame=%lldLL",(long long)TGLRnrCtx::kWireFrame).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEPass),-1,-2,1,G__FastAllocString(2048).Format("kPassUndef=%lldLL",(long long)TGLRnrCtx::kPassUndef).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEPass),-1,-2,1,G__FastAllocString(2048).Format("kPassFill=%lldLL",(long long)TGLRnrCtx::kPassFill).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEPass),-1,-2,1,G__FastAllocString(2048).Format("kPassOutlineFill=%lldLL",(long long)TGLRnrCtx::kPassOutlineFill).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEPass),-1,-2,1,G__FastAllocString(2048).Format("kPassOutlineLine=%lldLL",(long long)TGLRnrCtx::kPassOutlineLine).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEPass),-1,-2,1,G__FastAllocString(2048).Format("kPassWireFrame=%lldLL",(long long)TGLRnrCtx::kPassWireFrame).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLELODPresets),-1,-2,1,G__FastAllocString(2048).Format("kLODUndef=%lldLL",(long long)TGLRnrCtx::kLODUndef).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLELODPresets),-1,-2,1,G__FastAllocString(2048).Format("kLODPixel=%lldLL",(long long)TGLRnrCtx::kLODPixel).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLELODPresets),-1,-2,1,G__FastAllocString(2048).Format("kLODLow=%lldLL",(long long)TGLRnrCtx::kLODLow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLELODPresets),-1,-2,1,G__FastAllocString(2048).Format("kLODMed=%lldLL",(long long)TGLRnrCtx::kLODMed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLELODPresets),-1,-2,1,G__FastAllocString(2048).Format("kLODHigh=%lldLL",(long long)TGLRnrCtx::kLODHigh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel),-1,-2,1,G__FastAllocString(2048).Format("kSSLNotSelected=%lldLL",(long long)TGLRnrCtx::kSSLNotSelected).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel),-1,-2,1,G__FastAllocString(2048).Format("kSSLSelected=%lldLL",(long long)TGLRnrCtx::kSSLSelected).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel),-1,-2,1,G__FastAllocString(2048).Format("kSSLImpliedSelected=%lldLL",(long long)TGLRnrCtx::kSSLImpliedSelected).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel),-1,-2,1,G__FastAllocString(2048).Format("kSSLHighlighted=%lldLL",(long long)TGLRnrCtx::kSSLHighlighted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel),-1,-2,1,G__FastAllocString(2048).Format("kSSLImpliedHighlighted=%lldLL",(long long)TGLRnrCtx::kSSLImpliedHighlighted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel),-1,-2,1,G__FastAllocString(2048).Format("kSSLEnd=%lldLL",(long long)TGLRnrCtx::kSSLEnd).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase),-1,-1,2,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCamera),-1,-1,2,"fCamera=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo),-1,-1,2,"fSceneInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fViewerLOD=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fSceneLOD=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fCombiLOD=",0,"Combined viewer/scene lod.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fShapeLOD=",0,"LOD calculated for current shape.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fShapePixSize=",0,"Only relevant when not using display lists.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fViewerStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fSceneStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fViewerWFLineW=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSceneWFLineW=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fViewerOLLineW=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSceneOLLineW=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fViewerClip=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fSceneClip=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fClip=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fDrawPass=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch),-1,-1,2,"fStopwatch=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRenderTimeOut=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsRunning=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasTimedOut=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHighlight=",0,"True when in highlight.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHighlightOutline=",0,"True when in highlight-outline.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSecSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPickRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLRect),-1,-1,2,"fPickRectangle=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer),-1,-1,2,"fSelectBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR),G__defined_typename("lpTGLColorSet_t"),-1,2,"fColorSetStack=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRenderScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fEventKeySym=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDLCaptureOpen=",0,"! DL-capture currently open");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity),-1,-1,2,"fGLCtxIdentity=",0,"! Current GL context identity");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_GLUquadric),-1,-1,2,"fQuadric=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGrabImage=",0,"Set to true to store the image.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fGrabBuffer=",0,"Which buffer to grab after render.");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fGrabbedImage=",0,"Buffer where image was stored after rendering.");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSelectRecord */
static void G__setup_memvarTGLSelectRecord(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord));
   { TGLSelectRecord *p; p=(TGLSelectRecord*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TGLSelectRecord::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult),-1,-2,1,G__FastAllocString(2048).Format("kEnteringSelection=%lldLL",(long long)TGLSelectRecord::kEnteringSelection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult),-1,-2,1,G__FastAllocString(2048).Format("kLeavingSelection=%lldLL",(long long)TGLSelectRecord::kLeavingSelection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult),-1,-2,1,G__FastAllocString(2048).Format("kModifyingInternalSelection=%lldLL",(long long)TGLSelectRecord::kModifyingInternalSelection).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTransparent=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo),-1,-1,2,"fSceneInfo=",0,"SceneInfo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,2,"fPhysShape=",0,"PhysicalShape, if applicable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TObject),-1,-1,2,"fObject=",0,"Master TObject, if applicable");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fSpecific=",0,"Scene specific, if applicable");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMultiple=",0,"Mutliple selection requested (set by event-handler).");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHighlight=",0,"Requested for highlight (set by event-handler).");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult),-1,-1,2,"fSecSelRes=",0,"Result of ProcessSelection;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLViewer */
static void G__setup_memvarTGLViewer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer));
   { TGLViewer *p; p=(TGLViewer*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraPerspXOZ=%lldLL",(long long)TGLViewer::kCameraPerspXOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraPerspYOZ=%lldLL",(long long)TGLViewer::kCameraPerspYOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraPerspXOY=%lldLL",(long long)TGLViewer::kCameraPerspXOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraOrthoXOY=%lldLL",(long long)TGLViewer::kCameraOrthoXOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraOrthoXOZ=%lldLL",(long long)TGLViewer::kCameraOrthoXOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraOrthoZOY=%lldLL",(long long)TGLViewer::kCameraOrthoZOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraOrthoXnOY=%lldLL",(long long)TGLViewer::kCameraOrthoXnOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraOrthoXnOZ=%lldLL",(long long)TGLViewer::kCameraOrthoXnOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLECameraType),-1,-2,1,G__FastAllocString(2048).Format("kCameraOrthoZnOY=%lldLL",(long long)TGLViewer::kCameraOrthoZnOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLESecSelType),-1,-2,1,G__FastAllocString(2048).Format("kOnRequest=%lldLL",(long long)TGLViewer::kOnRequest).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLESecSelType),-1,-2,1,G__FastAllocString(2048).Format("kOnKeyMod1=%lldLL",(long long)TGLViewer::kOnKeyMod1).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TVirtualPad),-1,-1,2,"fPad=",0,"! external pad - remove replace with signal");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TContextMenu),-1,-1,2,"fContextMenu=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera),-1,-1,2,"fPerspectiveCameraXOZ=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera),-1,-1,2,"fPerspectiveCameraYOZ=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera),-1,-1,2,"fPerspectiveCameraXOY=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),-1,-1,2,"fOrthoXOYCamera=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),-1,-1,2,"fOrthoXOZCamera=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),-1,-1,2,"fOrthoZOYCamera=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),-1,-1,2,"fOrthoXnOYCamera=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),-1,-1,2,"fOrthoXnOZCamera=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera),-1,-1,2,"fOrthoZnOYCamera=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCamera),-1,-1,2,"fCurrentCamera=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator),-1,-1,2,"fAutoRotator=",0,"!");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStereo=",0,"! use stereo rendering");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fStereoZeroParallax=",0,"! position of zero-parallax plane: 0 - near clipping plane, 1 - far clipping plane");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fStereoEyeOffsetFac=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fStereoFrustumAsymFac=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLightSet),-1,-1,2,"fLightSet=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipSet),-1,-1,2,"fClipSet=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord),-1,-1,2,"fCurrentSelRec=",0,"! select record in use as selected");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord),-1,-1,2,"fSelRec=",0,"! select record from last select (should go to context)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord),-1,-1,2,"fSecSelRec=",0,"! select record from last secondary select (should go to context)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLManipSet),-1,-1,2,"fSelectedPShapeRef=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),-1,-1,2,"fCurrentOvlElm=",0,"! current overlay element");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord),-1,-1,2,"fOvlSelRec=",0,"! select record from last overlay select");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGEventHandler),-1,-1,2,"fEventHandler=",0,"! event handler");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGedEditor),-1,-1,2,"fGedEditor=",0,"! GED editor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj),-1,-1,2,"fPShapeWrap=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEPushAction),-1,-2,1,G__FastAllocString(2048).Format("kPushStd=%lldLL",(long long)TGLViewer::kPushStd).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEPushAction),-1,-2,1,G__FastAllocString(2048).Format("kPushCamCenter=%lldLL",(long long)TGLViewer::kPushCamCenter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEPushAction),-1,-2,1,G__FastAllocString(2048).Format("kPushAnnotate=%lldLL",(long long)TGLViewer::kPushAnnotate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction),-1,-2,1,G__FastAllocString(2048).Format("kDragNone=%lldLL",(long long)TGLViewer::kDragNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction),-1,-2,1,G__FastAllocString(2048).Format("kDragCameraRotate=%lldLL",(long long)TGLViewer::kDragCameraRotate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction),-1,-2,1,G__FastAllocString(2048).Format("kDragCameraTruck=%lldLL",(long long)TGLViewer::kDragCameraTruck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction),-1,-2,1,G__FastAllocString(2048).Format("kDragCameraDolly=%lldLL",(long long)TGLViewer::kDragCameraDolly).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction),-1,-2,1,G__FastAllocString(2048).Format("kDragOverlay=%lldLL",(long long)TGLViewer::kDragOverlay).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEPushAction),-1,-1,2,"fPushAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction),-1,-1,2,"fDragAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLRedrawTimer),-1,-1,2,"fRedrawTimer=",0,"! timer for triggering redraws");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxSceneDrawTimeHQ=",0,"! max time for scene rendering at high LOD (in ms)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxSceneDrawTimeLQ=",0,"! max time for scene rendering at high LOD (in ms)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLRect),-1,-1,2,"fViewport=",0,"! viewport - drawn area");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColorSet),-1,-1,2,"fDarkColorSet=",0,"! color-set with dark background");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColorSet),-1,-1,2,"fLightColorSet=",0,"! color-set with light background");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPointScale=",0,"! size scale for points");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLineScale=",0,"! width scale for lines");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmoothPoints=",0,"! smooth point edge rendering");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmoothLines=",0,"! smooth line edge rendering");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fAxesType=",0,"! axes type");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAxesDepthTest=",0,"! remove guides hidden-lines");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReferenceOn=",0,"! reference marker on?");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,2,"fReferencePos=",0,"! reference position");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawCameraCenter=",0,"! reference marker on?");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay),-1,-1,2,"fCameraOverlay=",0,"! markup size of viewport in scene units");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmartRefresh=",0,"! cache logicals during scene rebuilds");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDebugMode=",0,"! debug mode (forced rebuild + draw scene/frustum/interest boxes)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsPrinting=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,2,"fPictureFileName=",0,"! default file-name for SavePicture()");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFader=",0,"! fade the view (0 - no fade/default, 1 - full fade/no rendering done)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLColorSet),-1,-2,2,"fgDefaultColorSet=",0,"! a shared, default color-set");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgUseDefaultColorSetForNewViewers=",0,"! name says it all");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLWidget),-1,-1,2,"fGLWidget=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fGLDevice=",0,"!for embedded gl viewer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity),-1,-1,2,"fGLCtxId=",0,"!for embedded gl viewer");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIgnoreSizesOnUpdate=",0,"ignore sizes of bounding-boxes on update");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fResetCamerasOnUpdate=",0,"reposition camera on each update");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fResetCamerasOnNextUpdate=",0,"reposition camera on next update");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSceneBase */
static void G__setup_memvarTGLSceneBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase));
   { TGLSceneBase *p; p=(TGLSceneBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgSceneIDSrc=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fSceneID=",0,"Unique scene id.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,2,"fName=",0,"Object identifier.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,2,"fTitle=",0,"Object title.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTimeStamp=",0,"Counter increased on every update.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMinorStamp=",0,"Counter increased on minimal update.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fLOD=",0,"Scene-lod.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fStyle=",0,"Scene-style.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWFLineW=",0,"Scene wire-frame line-width.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fOLLineW=",0,"Scene outline line-width.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fClip=",0,"Scene clipping-plane.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSelectable=",0,"Objects in the scene are selectable.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,2,"fBoundingBox=",0,"bounding box for scene (axis aligned) - lazy update - use BoundingBox() to access");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBoundingBoxValid=",0,"bounding box valid?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDoFrustumCheck=",0,"Perform global frustum-check in UpdateSceneInfo()");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDoClipCheck=",0,"Perform global clip-plane-check in UpdateSceneInfo()");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgR),G__defined_typename("ViewerList_t"),-1,2,"fViewers=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoDestruct=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLScene */
static void G__setup_memvarTGLScene(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   { TGLScene *p; p=(TGLScene*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR),G__defined_typename("LogicalShapeMap_t"),-1,2,"fLogicalShapes=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR),G__defined_typename("PhysicalShapeMap_t"),-1,2,"fPhysicalShapes=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity),-1,-1,2,"fGLCtxIdentity=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInSmartRefresh=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR),G__defined_typename("LogicalShapeMap_t"),-1,2,"fSmartRefreshCache=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLastPointSizeScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLastLineWidthScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLogicalShape */
static void G__setup_memvarTGLLogicalShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape));
   { TGLLogicalShape *p; p=(TGLLogicalShape*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes),-1,-2,1,G__FastAllocString(2048).Format("kLODAxesNone=%lldLL",(long long)TGLLogicalShape::kLODAxesNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes),-1,-2,1,G__FastAllocString(2048).Format("kLODAxesX=%lldLL",(long long)TGLLogicalShape::kLODAxesX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes),-1,-2,1,G__FastAllocString(2048).Format("kLODAxesY=%lldLL",(long long)TGLLogicalShape::kLODAxesY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes),-1,-2,1,G__FastAllocString(2048).Format("kLODAxesZ=%lldLL",(long long)TGLLogicalShape::kLODAxesZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes),-1,-2,1,G__FastAllocString(2048).Format("kLODAxesAll=%lldLL",(long long)TGLLogicalShape::kLODAxesAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fRef=",0,"! physical instance ref counting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,2,"fFirstPhysical=",0,"! first replica");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TObject),-1,-1,2,"fExternalObj=",0,"! Also plays the role of ID.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,2,"fBoundingBox=",0,"! Shape's bounding box.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLScene),-1,-1,2,"fScene=",0,"! scene where object is stored (can be zero!)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDLBase=",0,"! display-list id base");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDLSize=",0,"! display-list size for different LODs");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fDLValid=",0,"! display-list validity bit-field");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDLCache=",0,"! use display list caching");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRefStrong=",0,"! Strong ref (delete on 0 ref); not in scene");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnExtObj=",0,"! External object is a fake");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLObject */
static void G__setup_memvarTGLObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLObject));
   { TGLObject *p; p=(TGLObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TMap),-1,-2,4,"fgGLClassMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMultiColor=",0,"Are multiple colors used for object rendering.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLManip */
static void G__setup_memvarTGLManip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManip));
   { TGLManip *p; p=(TGLManip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,2,"fShape=",0,"! manipulated shape");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fSelectedWidget=",0,"! active width (axis) component");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"! manipulator is active?");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fFirstMouse=",0,"! first (start) mouse position (in WINDOW coords)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fLastMouse=",0,"! last (latest) mouse position (in WINDOW coords)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLContext */
static void G__setup_memvarTGLContext(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLContext));
   { TGLContext *p; p=(TGLContext*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPaintDevice),-1,-1,4,"fDevice=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContextPrivate),-1,-1,4,"fPimpl=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFromCtor=",0,"To prohibit user's calls of SetContext.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity),-1,-1,4,"fIdentity=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgGlewInitDone=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLFormat */
static void G__setup_memvarTGLFormat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFormat));
   { TGLFormat *p; p=(TGLFormat*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TGLFormat::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kDoubleBuffer=%lldLL",(long long)TGLFormat::kDoubleBuffer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kDepth=%lldLL",(long long)TGLFormat::kDepth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kAccum=%lldLL",(long long)TGLFormat::kAccum).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kStencil=%lldLL",(long long)TGLFormat::kStencil).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kStereo=%lldLL",(long long)TGLFormat::kStereo).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFormatcLcLEFormatOptions),-1,-2,1,G__FastAllocString(2048).Format("kMultiSample=%lldLL",(long long)TGLFormat::kMultiSample).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoubleBuffered=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStereo=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDepthSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAccumSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStencilSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSamples=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-2,4,"fgAvailableSamples=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPlotBox */
static void G__setup_memvarTGLPlotBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox));
   { TGLPlotBox *p; p=(TGLPlotBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TColor),-1,-1,4,"fFrameColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,1,-1,G__defined_typename("Bool_t"),-1,4,"fXOYSelectable=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,1,-1,G__defined_typename("Bool_t"),-1,4,"fXOZSelectable=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,1,-1,G__defined_typename("Bool_t"),-1,4,"fYOZSelectable=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSelectablePairs[4][2]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"f3DBox[8]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"f2DBox[8]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"f2DBoxU[8]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFrontPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRangeXU=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRangeYU=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRangeZU=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLPlotBox::fgFramePlanes),105,0,1,-1,G__defined_typename("Int_t"),-2,1,"fgFramePlanes[][4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLPlotBox::fgBackPairs),105,0,1,-1,G__defined_typename("Int_t"),-2,1,"fgBackPairs[][2]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TGLPlotBox::fgNormals),100,0,1,-1,G__defined_typename("Double_t"),-2,1,"fgNormals[][3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPlotCamera */
static void G__setup_memvarTGLPlotCamera(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera));
   { TGLPlotCamera *p; p=(TGLPlotCamera*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLRect),-1,-1,2,"fViewport=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZoom=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fShift=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOrthoBox[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,2,"fCenter=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fTruck=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TArcBall),-1,-1,2,"fArcBall=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fMousePos=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fVpChanged=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGL5DDataSet */
static void G__setup_memvarTGL5DDataSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet));
   { TGL5DDataSet *p; p=(TGL5DDataSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetcLcLEdefaults),-1,-2,4,"kDefaultNB=50LL",0,(char*)NULL);
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNP=",0,"Number of entries.");
   G__memvar_setup((void*)0,68,0,1,-1,G__defined_typename("Double_t"),-1,4,"fV1=",0,"V1.");
   G__memvar_setup((void*)0,68,0,1,-1,G__defined_typename("Double_t"),-1,4,"fV2=",0,"V2.");
   G__memvar_setup((void*)0,68,0,1,-1,G__defined_typename("Double_t"),-1,4,"fV3=",0,"V3.");
   G__memvar_setup((void*)0,68,0,1,-1,G__defined_typename("Double_t"),-1,4,"fV4=",0,"V4.");
   G__memvar_setup((void*)0,68,0,1,-1,G__defined_typename("Double_t"),-1,4,"fV5=",0,"V5.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fV1MinMax=",0,"V1 range.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fV1Range=",0,"max - min.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fV2MinMax=",0,"V2 range.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fV2Range=",0,"max - min.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fV3MinMax=",0,"V3 range.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fV3Range=",0,"max - min.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fV4MinMax=",0,"V4 range.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fV5MinMax=",0,"V5 range.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,4,"fXAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,4,"fYAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,4,"fZAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fV4IsString=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETGLHistPaintergR),-1,-1,4,"fPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<UInt_t>"),-1,4,"fIndices=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLBoxCut */
static void G__setup_memvarTGLBoxCut(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut));
   { TGLBoxCut *p; p=(TGLBoxCut*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fYLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"fCenter=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fXRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fYRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fZRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,5,G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox),-1,-1,4,"fPlotBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fActive=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFactor=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,4,"fMousePos=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLTH3Slice */
static void G__setup_memvarTGLTH3Slice(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice));
   { TGLTH3Slice *p; p=(TGLTH3Slice*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTH3SlicecLcLESliceAxis),-1,-2,1,G__FastAllocString(2048).Format("kXOZ=%lldLL",(long long)TGLTH3Slice::kXOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTH3SlicecLcLESliceAxis),-1,-2,1,G__FastAllocString(2048).Format("kYOZ=%lldLL",(long long)TGLTH3Slice::kYOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTH3SlicecLcLESliceAxis),-1,-2,1,G__FastAllocString(2048).Format("kXOY=%lldLL",(long long)TGLTH3Slice::kXOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3SlicecLcLESliceAxis),-1,-1,4,"fAxisType=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,4,"fAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLevelPalette),-1,-1,4,"fPalette=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates),-1,-1,4,"fCoord=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox),-1,-1,4,"fBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSliceWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TH3),-1,-1,4,"fHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TF3),-1,-1,4,"fF3=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylEdoublegR),G__defined_typename("TGL2DArray<Double_t>"),-1,4,"fTexCoords=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fMinMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPlotPainter */
static void G__setup_memvarTGLPlotPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter));
   { TGLPlotPainter *p; p=(TGLPlotPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GLLN_TColor),-1,-1,4,"fPadColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPadPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPadTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TH1),-1,-1,2,"fHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,2,"fXAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,2,"fYAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,2,"fZAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates),-1,-1,2,"fCoord=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera),-1,-1,2,"fCamera=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer),-1,-1,2,"fSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUpdateSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSelectionPass=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSelectedPart=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fMousePosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXOZSectionPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYOZSectionPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXOYSectionPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox),-1,-1,2,"fBackBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut),-1,-1,2,"fBoxCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,2,"fZLevels=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHighColor=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPaintercLcLESelectionBase),-1,-2,2,"kHighColorSelectionBase=7LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPaintercLcLESelectionBase),-1,-2,2,"kTrueColorSelectionBase=10LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPaintercLcLESelectionBase),-1,-1,2,"fSelectionBase=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawPalette=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPaintercLcLECutAxisID),-1,-2,1,G__FastAllocString(2048).Format("kXAxis=%lldLL",(long long)TGLPlotPainter::kXAxis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPaintercLcLECutAxisID),-1,-2,1,G__FastAllocString(2048).Format("kYAxis=%lldLL",(long long)TGLPlotPainter::kYAxis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPaintercLcLECutAxisID),-1,-2,1,G__FastAllocString(2048).Format("kZAxis=%lldLL",(long long)TGLPlotPainter::kZAxis).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPlot3D */
static void G__setup_memvarTGLPlot3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D));
   { TGLPlot3D *p; p=(TGLPlot3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter),-1,-1,2,"fPlotPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates),-1,-1,2,"fCoord=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TF2GL */
static void G__setup_memvarTF2GL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TF2GL));
   { TF2GL *p; p=(TF2GL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TF2),-1,-1,2,"fM=",0,"fModel dynamic-casted to TH2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TH2),-1,-1,2,"fH=",0,"Visualization histogram.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGL5DDataSetEditor */
static void G__setup_memvarTGL5DDataSetEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor));
   { TGL5DDataSetEditor *p; p=(TGL5DDataSetEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fNCellsXEntry=",0,"Number of cells along X.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fNCellsYEntry=",0,"Number of cells along Y.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fNCellsZEntry=",0,"Number of cells along Z.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGDoubleHSlider),-1,-1,4,"fXRangeSlider=",0,"Slider for X range.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fXRangeSliderMin=",0,"Number entry for slider's min.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fXRangeSliderMax=",0,"Number entry for slider's max.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGDoubleHSlider),-1,-1,4,"fYRangeSlider=",0,"Slider for Y range.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fYRangeSliderMin=",0,"Number entry for slider's min.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fYRangeSliderMax=",0,"Number entry for slider's max.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGDoubleHSlider),-1,-1,4,"fZRangeSlider=",0,"Slider for Z range.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fZRangeSliderMin=",0,"Number entry for slider's min.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fZRangeSliderMax=",0,"Number entry for slider's max.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fCancelGridBtn=",0,"\"Cancel\" button.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fOkGridBtn=",0,"\"Apply\" button.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fV4MinEntry=",0,"Read only widget.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntryField),-1,-1,4,"fV4MaxEntry=",0,"Read only widget.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fHighlightCheck=",0,"Highlight selected surface.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGListBox),-1,-1,4,"fIsoList=",0,"List box to select surface.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fVisibleCheck=",0,"Show/hide surface.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fShowCloud=",0,"Show/hide points for surface.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGColorSelect),-1,-1,4,"fSurfColorSelect=",0,"Open color dialog.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGHSlider),-1,-1,4,"fSurfAlphaSlider=",0,"Slider to control transparency.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fSurfRemoveBtn=",0,"Remove selected surface.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fNewIsoEntry=",0,"Set the iso-level for new surface.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fAddNewIsoBtn=",0,"Button to add new iso.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fShowBoxCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fNumberOfPlanes=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fAlpha=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fLogScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGDoubleHSlider),-1,-1,4,"fSlideRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fApplyAlpha=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fApplyPlanes=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet),-1,-1,4,"fDataSet=",0,"Data adapter for TTree.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL5DPainter),-1,-1,4,"fPainter=",0,"Painter.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditorcLcLTGL5DEditorPrivate),-1,-1,4,"fHidden=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSelectedSurface=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLParametricEquation */
static void G__setup_memvarTGLParametricEquation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation));
   { TGLParametricEquation *p; p=(TGLParametricEquation*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETF2gR),G__defined_typename("Ptr_t"),-1,4,"fXEquation=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETF2gR),G__defined_typename("Ptr_t"),-1,4,"fYEquation=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETF2gR),G__defined_typename("Ptr_t"),-1,4,"fZEquation=",0,(char*)NULL);
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ParametricEquation_t"),-1,4,"fEquation=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fURange=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fVRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fConstrained=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fModified=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETGLHistPaintergR),G__defined_typename("Painter_t"),-1,4,"fPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLTH3Composition */
static void G__setup_memvarTGLTH3Composition(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition));
   { TGLTH3Composition *p; p=(TGLTH3Composition*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositioncLcLETH3BinShape),-1,-2,1,G__FastAllocString(2048).Format("kBox=%lldLL",(long long)TGLTH3Composition::kBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositioncLcLETH3BinShape),-1,-2,1,G__FastAllocString(2048).Format("kSphere=%lldLL",(long long)TGLTH3Composition::kSphere).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR),G__defined_typename("vector<TH3Pair_t>"),-1,4,"fHists=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETGLHistPaintergR),-1,-1,4,"fPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLHistPainter */
static void G__setup_memvarTGLHistPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter));
   { TGLHistPainter *p; p=(TGLHistPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETVirtualHistPaintergR),-1,-1,4,"fDefaultPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_auto_ptrlETGLPlotPaintergR),-1,-1,4,"fGLPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation),-1,-1,4,"fEq=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TH1),-1,-1,4,"fHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TF3),-1,-1,4,"fF3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TList),-1,-1,4,"fStack=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_EGLPlotType),-1,-1,4,"fPlotType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera),-1,-1,4,"fCamera=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates),-1,-1,4,"fCoord=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLAdapter */
static void G__setup_memvarTGLAdapter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAdapter));
   { TGLAdapter *p; p=(TGLAdapter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGLDevice=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLOvlSelectRecord */
static void G__setup_memvarTGLOvlSelectRecord(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord));
   { TGLOvlSelectRecord *p; p=(TGLOvlSelectRecord*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement),-1,-1,2,"fOvlElement=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLOverlayElement */
static void G__setup_memvarTGLOverlayElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement));
   { TGLOverlayElement *p; p=(TGLOverlayElement*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLERole),-1,-2,1,G__FastAllocString(2048).Format("kUser=%lldLL",(long long)TGLOverlayElement::kUser).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLERole),-1,-2,1,G__FastAllocString(2048).Format("kViewer=%lldLL",(long long)TGLOverlayElement::kViewer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLERole),-1,-2,1,G__FastAllocString(2048).Format("kAnnotation=%lldLL",(long long)TGLOverlayElement::kAnnotation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLERole),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TGLOverlayElement::kAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kInvisible=%lldLL",(long long)TGLOverlayElement::kInvisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kDisabled=%lldLL",(long long)TGLOverlayElement::kDisabled).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kActive=%lldLL",(long long)TGLOverlayElement::kActive).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kAllVisible=%lldLL",(long long)TGLOverlayElement::kAllVisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLERole),-1,-1,2,"fRole=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLEState),-1,-1,2,"fState=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLOverlayList */
static void G__setup_memvarTGLOverlayList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayList));
   { TGLOverlayList *p; p=(TGLOverlayList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR),G__defined_typename("list<TGLOverlayElement*>"),-1,2,"fElements=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLFontManager */
static void G__setup_memvarTGLFontManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   { TGLFontManager *p; p=(TGLFontManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),G__defined_typename("FontMap_t"),-1,2,"fFontMap=",0,"map of created fonts");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR),G__defined_typename("FontList_t"),-1,2,"fFontTrash=",0,"fonts to purge");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TObjArray),-1,-2,2,"fgFontFileArray=",0,"map font-id to ttf-font-file");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("FontSizeVec_t"),-2,2,"fgFontSizeArray=",0,"map of valid font-size");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgStaticInitDone=",0,"global initialization flag");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLFont */
static void G__setup_memvarTGLFont(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFont));
   { TGLFont *p; p=(TGLFont*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kUndef=%lldLL",(long long)TGLFont::kUndef).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kBitmap=%lldLL",(long long)TGLFont::kBitmap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kPixmap=%lldLL",(long long)TGLFont::kPixmap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kTexture=%lldLL",(long long)TGLFont::kTexture).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kOutline=%lldLL",(long long)TGLFont::kOutline).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kPolygon=%lldLL",(long long)TGLFont::kPolygon).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kExtrude=%lldLL",(long long)TGLFont::kExtrude).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignH_e),-1,-2,1,G__FastAllocString(2048).Format("kLeft=%lldLL",(long long)TGLFont::kLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignH_e),-1,-2,1,G__FastAllocString(2048).Format("kRight=%lldLL",(long long)TGLFont::kRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignH_e),-1,-2,1,G__FastAllocString(2048).Format("kCenterH=%lldLL",(long long)TGLFont::kCenterH).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignV_e),-1,-2,1,G__FastAllocString(2048).Format("kBottom=%lldLL",(long long)TGLFont::kBottom).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignV_e),-1,-2,1,G__FastAllocString(2048).Format("kTop=%lldLL",(long long)TGLFont::kTop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignV_e),-1,-2,1,G__FastAllocString(2048).Format("kCenterV=%lldLL",(long long)TGLFont::kCenterV).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_FTFont),-1,-1,4,"fFont=",0,"FTGL font.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager),-1,-1,4,"fManager=",0,"Font manager.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDepth=",0,"depth of extruded fonts, enforced at render time.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"free-type face size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFile=",0,"free-type file name");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-1,2,"fMode=",0,"free-type FTGL class id");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTrashCount=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLViewerBase */
static void G__setup_memvarTGLViewerBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   { TGLViewerBase *p; p=(TGLViewerBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx),-1,-1,2,"fRnrCtx=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCamera),-1,-1,2,"fCamera=",0,"Camera for rendering.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fClip=",0,"Viewer clipping-plane.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fLOD=",0,"Viewer-lod for rendering.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fStyle=",0,"Viewer-style for rendering.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWFLineW=",0,"Optional override of scene wire-frame line-width");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fOLLineW=",0,"Optional override of scene outline line-width");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fResetSceneInfosOnRender=",0,"Request rebuild of view-specific scene data.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,"Change requiring redraw is pending.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR),G__defined_typename("SceneInfoList_t"),-1,2,"fScenes=",0,"Registered scenes.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR),G__defined_typename("SceneInfoVec_t"),-1,2,"fVisScenes=",0,"Visible scenes.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,2,"fOverallBoundingBox=",0,"Axis-aligned union of scene bboxes.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR),G__defined_typename("OverlayElmVec_t"),-1,2,"fOverlay=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLAnnotation */
static void G__setup_memvarTGLAnnotation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation));
   { TGLAnnotation *p; p=(TGLAnnotation*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLEDrag),-1,-2,2,"kMove=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLEDrag),-1,-2,2,"kResize=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLEDrag),-1,-2,2,"kNone=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLENameStack),-1,-2,2,"kMoveID=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLENameStack),-1,-2,2,"kEditID=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLENameStack),-1,-2,2,"kDeleteID=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLENameStack),-1,-2,2,"kResizeID=3LL",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPosX=",0,"x position [0, 1]");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPosY=",0,"y position [0, 1]");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fHeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMouseX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMouseY=",0,"! last mouse position");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLAnnotationcLcLEDrag),-1,-1,2,"fDrag=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDrawW=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDrawH=",0,"! width and height when drawing");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTextSizeDrag=",0,"! text-size at start of drag");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fPointer=",0,"picked location in 3D space");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"active item identifier");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGMainFrame),-1,-1,2,"fMainFrame=",0,"editors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextEdit),-1,-1,2,"fTextEdit=",0,"editors");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-2,2,"fgBackColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-2,2,"fgTextColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewer),-1,-1,2,"fParent=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,2,"fText=",0,"annotation text");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTextSize=",0,"relative font size");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFont),-1,-1,2,"fFont=",0,"font used to render labels");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFont),-1,-1,2,"fMenuFont=",0,"font used to render menu buttons");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignH_e),-1,-1,2,"fTextAlign=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fBackColor=",0,"background color");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fTextColor=",0,"text color");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fTransparency=",0,"transparency of background");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawRefLine=",0,"draw 3D refrence line");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseColorSet=",0,"use color set from rnrCtx");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAllowClose=",0,"allow closing via 'X' button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLAutoRotator */
static void G__setup_memvarTGLAutoRotator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator));
   { TGLAutoRotator *p; p=(TGLAutoRotator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewer),-1,-1,2,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCamera),-1,-1,2,"fCamera=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TTimer),-1,-1,2,"fTimer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TStopwatch),-1,-1,2,"fWatch=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDt=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fATheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWDolly=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fADolly=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetaA0=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDollyA0=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTimerRunning=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLText */
static void G__setup_memvarTGLText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLText));
   { TGLText *p; p=(TGLText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fX=",0,"X position");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fY=",0,"Y position");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZ=",0,"Z position");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAngle1=",0,"1st angle.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAngle2=",0,"2nd angle.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAngle3=",0,"3rd angle.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_FTFont),-1,-1,4,"fGLTextFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLAxis */
static void G__setup_memvarTGLAxis(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxis));
   { TGLAxis *p; p=(TGLAxis*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNDiv=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNDiv1=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNDiv2=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNDiv3=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTicks1=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTicks2=",0,(char*)NULL);
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTicks1=",0,(char*)NULL);
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTicks2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fLabels=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAxisLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTickMarksLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTickMarksOrientation=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLabelsOffset=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLabelsSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGridLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLText),-1,-1,4,"fText=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAngle1=",0,"1st labels' angle.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAngle2=",0,"2nd labels' angle.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAngle3=",0,"3rd labels' angle.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLAxisPainter */
static void G__setup_memvarTGLAxisPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   { TGLAxisPainter *p; p=(TGLAxisPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fExp=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxDigits=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDecimals=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fFormat=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFont),-1,-1,4,"fLabelFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFont),-1,-1,4,"fTitleFont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAttAxis),-1,-1,2,"fAttAxis=",0,"Model.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseAxisColors=",0,"Use colors from axes or from GL-rnr-ctx.");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode),-1,-1,2,"fFontMode=",0,"To be put into TAttAxis");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),G__defined_typename("LabVec_t"),-1,2,"fLabVec=",0,"List of Labels position-value pairs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),G__defined_typename("TMVec_t"),-1,2,"fTMVec=",0,"List of tick-mark position-value pairs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fDir=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fTMOff[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTMNDim=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLabelPixelFontSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLabel3DFontSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePixelFontSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTitle3DFontSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignH_e),-1,-1,2,"fLabelAlignH=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignV_e),-1,-1,2,"fLabelAlignV=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fTitlePos=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TPMERegexp),-1,-1,2,"fAllZeroesRE=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLAxisPainterBox */
static void G__setup_memvarTGLAxisPainterBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainterBox));
   { TGLAxisPainterBox *p; p=(TGLAxisPainterBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,2,"fAxisTitlePos[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,2,"fAxis[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLBoxPainter */
static void G__setup_memvarTGLBoxPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter));
   { TGLBoxPainter *p; p=(TGLBoxPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fXOZSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fYOZSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fXOYSlice=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoxPaintercLcLEBoxType),-1,-2,4,"kBox=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLBoxPaintercLcLEBoxType),-1,-2,4,"kBox1=1LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoxPaintercLcLEBoxType),-1,-1,4,"fType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fPlotInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fMinMaxVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLQuadric),-1,-1,4,"fQuadric=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLCameraGuide */
static void G__setup_memvarTGLCameraGuide(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide));
   { TGLCameraGuide *p; p=(TGLCameraGuide*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fXPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fYPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSelAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInDrag=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLCameraOverlay */
static void G__setup_memvarTGLCameraOverlay(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay));
   { TGLCameraOverlay *p; p=(TGLCameraOverlay*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kPlaneIntersect=%lldLL",(long long)TGLCameraOverlay::kPlaneIntersect).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kBar=%lldLL",(long long)TGLCameraOverlay::kBar).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kAxis=%lldLL",(long long)TGLCameraOverlay::kAxis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kGridFront=%lldLL",(long long)TGLCameraOverlay::kGridFront).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kGridBack=%lldLL",(long long)TGLCameraOverlay::kGridBack).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowOrthographic=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowPerspective=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-1,2,"fOrthographicMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlaycLcLEMode),-1,-1,2,"fPerspectiveMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter),-1,-1,2,"fAxisPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TAxis),-1,-1,2,"fAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAxisExtend=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseAxisColors=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlane),-1,-1,2,"fExternalRefPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseExternalRefPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFrustum[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPShapeRef */
static void G__setup_memvarTGLPShapeRef(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef));
   { TGLPShapeRef *p; p=(TGLPShapeRef*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef),-1,-1,4,"fNextPSRef=",0,"Internal pointer to the next reference (used by TGLPhysicalShape directly).");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,2,"fPShape=",0,"Pointer to referenced physical shape.");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLManipSet */
static void G__setup_memvarTGLManipSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManipSet));
   { TGLManipSet *p; p=(TGLManipSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLManipSetcLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kTrans=%lldLL",(long long)TGLManipSet::kTrans).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLManipSetcLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kScale=%lldLL",(long long)TGLManipSet::kScale).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLManipSetcLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kRotate=%lldLL",(long long)TGLManipSet::kRotate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLManipSetcLcLEManip),-1,-2,1,G__FastAllocString(2048).Format("kEndType=%lldLL",(long long)TGLManipSet::kEndType).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLManip),-1,-1,2,"fManip[3]=",0,"! manipulator store");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLManipSetcLcLEManip),-1,-1,2,"fType=",0,"! current manipulator");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawBBox=",0,"! also draw bounding-box around physical");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLClip */
static void G__setup_memvarTGLClip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClip));
   { TGLClip *p; p=(TGLClip*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLClipcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kOutside=%lldLL",(long long)TGLClip::kOutside).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLClipcLcLEMode),-1,-2,1,G__FastAllocString(2048).Format("kInside=%lldLL",(long long)TGLClip::kInside).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipcLcLEMode),-1,-1,2,"fMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTimeStamp=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLClipPlane */
static void G__setup_memvarTGLClipPlane(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane));
   { TGLClipPlane *p; p=(TGLClipPlane*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,1,-1,-1,-2,4,"fgColor[4]=",0,"! Fixed color of clip plane");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLClipBox */
static void G__setup_memvarTGLClipBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipBox));
   { TGLClipBox *p; p=(TGLClipBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,1,-1,-1,-2,4,"fgColor[4]=",0,"! Fixed color of clip box");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLClipSet */
static void G__setup_memvarTGLClipSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSet));
   { TGLClipSet *p; p=(TGLClipSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane),-1,-1,2,"fClipPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipBox),-1,-1,2,"fClipBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fCurrentClip=",0,"! the current clipping shape");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowClip=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowManip=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLManipSet),-1,-1,2,"fManip=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,2,"fLastBBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLClipSetSubEditor */
static void G__setup_memvarTGLClipSetSubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor));
   { TGLClipSetSubEditor *p; p=(TGLClipSetSubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipSet),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_EClipType),-1,-1,2,"fCurrentClip=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButtonGroup),-1,-1,2,"fTypeButtons=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,2,"fPlanePropFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,2,"fPlaneProp[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,2,"fBoxPropFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,2,"fBoxProp[6]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,2,"fClipInside=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,2,"fAutoUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,2,"fClipEdit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,2,"fClipShow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fApplyButton=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fResetButton=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLClipSetEditor */
static void G__setup_memvarTGLClipSetEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor));
   { TGLClipSetEditor *p; p=(TGLClipSetEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipSet),-1,-1,2,"fM=",0,"fModel dynamic-casted to TGLClipSet");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),-1,-1,2,"fSE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLContextIdentity */
static void G__setup_memvarTGLContextIdentity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   { TGLContextIdentity *p; p=(TGLContextIdentity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager),-1,-1,2,"fFontManager=",0,"FreeType font manager.");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCnt=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fClientCnt=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),G__defined_typename("DLTrash_t"),-1,4,"fDLTrash=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLContextmUcOallocatorlETGLContextmUgRsPgR),G__defined_typename("CtxList_t"),-1,4,"fCtxs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity),-1,-2,4,"fgDefaultIdentity=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLWidget */
static void G__setup_memvarTGLWidget(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget));
   { TGLWidget *p; p=(TGLWidget*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLContext),-1,-1,4,"fGLContext=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEvoidmUcOvoidmUgR),-1,-1,4,"fInnerData=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWindowIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFormat),-1,-1,4,"fGLFormat=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFromInit=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_setlETGLContextmUcOlesslETGLContextmUgRcOallocatorlETGLContextmUgRsPgR),G__defined_typename("set<TGLContext*>"),-1,4,"fValidContexts=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGEventHandler),-1,-1,4,"fEventHandler=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLCylinder */
static void G__setup_memvarTGLCylinder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCylinder));
   { TGLCylinder *p; p=(TGLCylinder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fR1=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fR2=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fR3=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fR4=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi1=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,4,"fLowPlaneNorm=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,4,"fHighPlaneNorm=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSegMesh=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLockable */
static void G__setup_memvarTGLLockable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLockable));
   { TGLLockable *p; p=(TGLLockable*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLockablecLcLELock),-1,-2,1,G__FastAllocString(2048).Format("kUnlocked=%lldLL",(long long)TGLLockable::kUnlocked).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLockablecLcLELock),-1,-2,1,G__FastAllocString(2048).Format("kDrawLock=%lldLL",(long long)TGLLockable::kDrawLock).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLockablecLcLELock),-1,-2,1,G__FastAllocString(2048).Format("kSelectLock=%lldLL",(long long)TGLLockable::kSelectLock).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLockablecLcLELock),-1,-2,1,G__FastAllocString(2048).Format("kModifyLock=%lldLL",(long long)TGLLockable::kModifyLock).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLockablecLcLELock),-1,-1,2,"fLock=",0,"Lock state.");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSceneInfo */
static void G__setup_memvarTGLSceneInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo));
   { TGLSceneInfo *p; p=(TGLSceneInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfocLcLEClipTest),-1,-2,1,G__FastAllocString(2048).Format("kClipNone=%lldLL",(long long)TGLSceneInfo::kClipNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfocLcLEClipTest),-1,-2,1,G__FastAllocString(2048).Format("kClipOutside=%lldLL",(long long)TGLSceneInfo::kClipOutside).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfocLcLEClipTest),-1,-2,1,G__FastAllocString(2048).Format("kClipInside=%lldLL",(long long)TGLSceneInfo::kClipInside).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase),-1,-1,2,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase),-1,-1,2,"fScene=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,"Show fScene in fViewer");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fLOD=",0,"Optional override of scene lod");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fStyle=",0,"Optional override of scene style");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWFLineW=",0,"Optional override of scene wire-frame line-width");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fOLLineW=",0,"Optional override of scene outline line-width");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fClip=",0,"Optional override of clipping-plane");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fLastLOD=",0,"Last combined viewer/scene lod   (set in scene::lodify-scene-info).");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fLastStyle=",0,"Last combined viewer/scene style (set in scene::pre-draw).");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLastWFLineW=",0,"Last combined viewer/scene wire-frame line-width (set in scene::pre-draw).");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLastOLLineW=",0,"Last combined viewer/scene outline line-width (set in scene::pre-draw).");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClip),-1,-1,2,"fLastClip=",0,"Last combined viewer/scene clip  (set in scene::update)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLCamera),-1,-1,2,"fLastCamera=",0,"Last camera used.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fSceneStamp=",0,"Scene's time-stamp on last update.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fClipStamp=",0,"Clip's time-stamp on last update.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCameraStamp=",0,"Camera's time-stamp on last update.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUpdateTimeouted=",0,"Set if update was interrupted.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,2,"fTransformedBBox=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fViewCheck=",0,"Viewer side check if render is necessary.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInFrustum=",0,"Is scene intersecting view-frustum.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInClip=",0,"Is scene contained within clipping-volume.");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fClipMode=",0,"Clipping mode, can be disbled.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR),G__defined_typename("TGLPlaneSet_t"),-1,2,"fFrustumPlanes=",0,"Clipping planes defined by frustum; only those intersecting the scene volume are kept.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR),G__defined_typename("TGLPlaneSet_t"),-1,2,"fClipPlanes=",0,"Clipping planes from clip-object; which planes are kept depends on inside/outside mode.");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLStopwatch */
static void G__setup_memvarTGLStopwatch(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch));
   { TGLStopwatch *p; p=(TGLStopwatch*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStart=",0,"! start time (millisec)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnd=",0,"! end time (millisec)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastRun=",0,"! time of last run (milisec)");
   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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSelectBuffer */
static void G__setup_memvarTGLSelectBuffer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer));
   { TGLSelectBuffer *p; p=(TGLSelectBuffer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufSize=",0,"Size of buffer.");
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBuf=",0,"Actual buffer.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNRecords=",0,"Number of records as returned by glRenderMode.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR),G__defined_typename("vRawRecord_t"),-1,2,"fSortedRecords=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgMaxBufSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSelectRecordBase */
static void G__setup_memvarTGLSelectRecordBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase));
   { TGLSelectRecordBase *p; p=(TGLSelectRecordBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,(char*)NULL);
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fItems=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMinZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,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__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPerspectiveCamera */
static void G__setup_memvarTGLPerspectiveCamera(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera));
   { TGLPerspectiveCamera *p; p=(TGLPerspectiveCamera*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFOV=",0,"!");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fgFOVMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fgFOVDefault=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fgFOVMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgFOVDeltaSens=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLOrthoCamera */
static void G__setup_memvarTGLOrthoCamera(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera));
   { TGLOrthoCamera *p; p=(TGLOrthoCamera*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-2,1,G__FastAllocString(2048).Format("kZOY=%lldLL",(long long)TGLOrthoCamera::kZOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-2,1,G__FastAllocString(2048).Format("kXOZ=%lldLL",(long long)TGLOrthoCamera::kXOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-2,1,G__FastAllocString(2048).Format("kXOY=%lldLL",(long long)TGLOrthoCamera::kXOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-2,1,G__FastAllocString(2048).Format("kZnOY=%lldLL",(long long)TGLOrthoCamera::kZnOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-2,1,G__FastAllocString(2048).Format("kXnOZ=%lldLL",(long long)TGLOrthoCamera::kXnOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-2,1,G__FastAllocString(2048).Format("kXnOY=%lldLL",(long long)TGLOrthoCamera::kXnOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCameracLcLEType),-1,-1,4,"fType=",0,"! camera type");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEnableRotate=",0,"! enable rotation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDollyToZoom=",0,"! zoom when dolly is requested");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomMin=",0,"! minimum zoom factor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomDefault=",0,"! default zoom factor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomMax=",0,"! maximum zoom factor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox),-1,-1,4,"fVolume=",0,"! scene volume");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDefXSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDefYSize=",0,"! x, y size of scene from camera view");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoom=",0,"! current zoom");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgZoomDeltaSens=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLViewerEditor */
static void G__setup_memvarTGLViewerEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor));
   { TGLViewerEditor *p; p=(TGLViewerEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fGuidesFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fClipFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fStereoFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),-1,-1,4,"fLightSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGColorSelect),-1,-1,4,"fClearColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fIgnoreSizesOnUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fResetCamerasOnUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fUpdateScene=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fCameraHome=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fMaxSceneDrawTimeHQ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fMaxSceneDrawTimeLQ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fPointSizeScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fLineWidthScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fPointSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fLineSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fWFLineWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fOLLineWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fCameraCenterExt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGTextButton),-1,-1,4,"fCaptureCenter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fDrawCameraCenter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fCameraCenterX=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fCameraCenterY=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fCameraCenterZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fCaptureAnnotate=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAxesType=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButtonGroup),-1,-1,4,"fAxesContainer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGRadioButton),-1,-1,4,"fAxesNone=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGRadioButton),-1,-1,4,"fAxesEdge=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGRadioButton),-1,-1,4,"fAxesOrigin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fAxesDepthTest=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGGroupFrame),-1,-1,4,"fRefContainer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fReferenceOn=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fReferencePosX=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fReferencePosY=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fReferencePosZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGGroupFrame),-1,-1,4,"fCamContainer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGComboBox),-1,-1,4,"fCamMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCheckButton),-1,-1,4,"fCamOverlayOn=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor),-1,-1,4,"fClipSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fARotDt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fARotWPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fARotATheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fARotWTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fARotADolly=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fARotWDolly=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fStereoZeroParallax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fStereoEyeOffsetFac=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fStereoFrustumAsymFac=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewer),-1,-1,4,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsInPad=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLightSet */
static void G__setup_memvarTGLLightSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSet));
   { TGLLightSet *p; p=(TGLLightSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightFront=%lldLL",(long long)TGLLightSet::kLightFront).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightTop=%lldLL",(long long)TGLLightSet::kLightTop).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightBottom=%lldLL",(long long)TGLLightSet::kLightBottom).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightLeft=%lldLL",(long long)TGLLightSet::kLightLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightRight=%lldLL",(long long)TGLLightSet::kLightRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightMask=%lldLL",(long long)TGLLightSet::kLightMask).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetcLcLELight),-1,-2,1,G__FastAllocString(2048).Format("kLightSpecular=%lldLL",(long long)TGLLightSet::kLightSpecular).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLightState=",0,"! light states (on/off) mask");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseSpecular=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFrontPower=",0,"! power of the front lamp");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSidePower=",0,"! power of the side lamps");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSpecularPower=",0,"! power of specular lamp");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPShapeObj */
static void G__setup_memvarTGLPShapeObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj));
   { TGLPShapeObj *p; p=(TGLPShapeObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fPShape)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,1,"fPShape=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fViewer)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewer),-1,-1,1,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLOutput */
static void G__setup_memvarTGLOutput(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOutput));
   { TGLOutput *p; p=(TGLOutput*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOutputcLcLEFormat),-1,-2,1,G__FastAllocString(2048).Format("kEPS_SIMPLE=%lldLL",(long long)TGLOutput::kEPS_SIMPLE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOutputcLcLEFormat),-1,-2,1,G__FastAllocString(2048).Format("kEPS_BSP=%lldLL",(long long)TGLOutput::kEPS_BSP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOutputcLcLEFormat),-1,-2,1,G__FastAllocString(2048).Format("kPDF_SIMPLE=%lldLL",(long long)TGLOutput::kPDF_SIMPLE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLOutputcLcLEFormat),-1,-2,1,G__FastAllocString(2048).Format("kPDF_BSP=%lldLL",(long long)TGLOutput::kPDF_BSP).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLEventHandler */
static void G__setup_memvarTGLEventHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler));
   { TGLEventHandler *p; p=(TGLEventHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewer),-1,-1,2,"fGLViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TTimer),-1,-1,2,"fMouseTimer=",0,"mouse delay timer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fButtonPushPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fLastPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fLastMouseOverPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape),-1,-1,2,"fLastMouseOverShape=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGToolTip),-1,-1,2,"fTooltip=",0,"tooltip for highlight");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fLastGlobalPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TPoint),-1,-1,2,"fTooltipPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fActiveButtonID=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLastEventState=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIgnoreButtonUp=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInPointerGrab=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMouseTimerRunning=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fTooltipShown=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTooltipPixelTolerance=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSecSelType=",0,"secondary selection type");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDoInternalSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fViewerCentricControls=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fArrowKeyFactor=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMouseDragFactor=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMouseWheelFactor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLFaderHelper */
static void G__setup_memvarTGLFaderHelper(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper));
   { TGLFaderHelper *p; p=(TGLFaderHelper*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fViewer)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLViewer),-1,-1,1,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fFadeTarget)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fFadeTarget=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTime)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fTime=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNSteps)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNSteps=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLEmbeddedViewer */
static void G__setup_memvarTGLEmbeddedViewer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer));
   { TGLEmbeddedViewer *p; p=(TGLEmbeddedViewer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBorder=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLFaceSet */
static void G__setup_memvarTGLFaceSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet));
   { TGLFaceSet *p; p=(TGLFaceSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVertices=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fNormals=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fPolyDesc=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNbPols=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgEnforceTriangles=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLFBO */
static void G__setup_memvarTGLFBO(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFBO));
   { TGLFBO *p; p=(TGLFBO*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFrameBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fColorTexture=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDepthBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMSFrameBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMSColorBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fW=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fH=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMSSamples=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMSCoverageSamples=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fHScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsRescaled=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgRescaleToPow2=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgMultiSampleNAWarned=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPadPainter */
static void G__setup_memvarTGLPadPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter));
   { TGLPadPainter *p; p=(TGLPadPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_RglcLcLPadcLcLPolygonStippleSet),-1,-1,4,"fSSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_RglcLcLPadcLcLTesselator),-1,-1,4,"fTess=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_RglcLcLPadcLcLMarkerPainter),-1,-1,4,"fMarker=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_RglcLcLPadcLcLGLLimits),-1,-1,4,"fLimits=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVs=",0,"Vertex buffer for tesselator.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFontManager),-1,-1,4,"fFM=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFont),-1,-1,4,"fF=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVp[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR),G__defined_typename("vector<TPoint>"),-1,4,"fPoly=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsHollowArea=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLocked=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLH2PolyPainter */
static void G__setup_memvarTGLH2PolyPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter));
   { TGLH2PolyPainter *p; p=(TGLH2PolyPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fBinInfo=",0,"Used by GetPlotInfo.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fBinColors=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fPolygon=",0,"Temporary array for polygon's vertices.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgR),G__defined_typename("list<Rgl::Pad::Tesselation_t>"),-1,4,"fCaps=",0,"Caps for all bins.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fZLog=",0,"Change in logZ updates only bin heights.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLegoPainter */
static void G__setup_memvarTGLLegoPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter));
   { TGLLegoPainter *p; p=(TGLLegoPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPaintercLcLELegoType),-1,-2,4,"kColorSimple=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPaintercLcLELegoType),-1,-2,4,"kColorLevel=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPaintercLcLELegoType),-1,-2,4,"kCylindricBars=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLegoPaintercLcLELegoType),-1,-1,4,"fLegoType=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fMinMaxVal=",0,"For texture coordinates generation.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),G__defined_typename("vector<Rgl::Range_t>"),-1,4,"fXEdges=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),G__defined_typename("vector<Rgl::Range_t>"),-1,4,"fYEdges=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),-1,-1,4,"fCosSinTableX=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),-1,-1,4,"fCosSinTableY=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fBinInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLQuadric),-1,-1,4,"fQuadric=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawErrors=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLevelPalette),-1,-1,4,"fPalette=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fColorLevels=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLightSetSubEditor */
static void G__setup_memvarTGLLightSetSubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor));
   { TGLLightSetSubEditor *p; p=(TGLLightSetSubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLightSet),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGGroupFrame),-1,-1,2,"fLightFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fTopLight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fRightLight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fBottomLight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fLeftLight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fFrontLight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,2,"fSpecularLight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLLightSetEditor */
static void G__setup_memvarTGLLightSetEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor));
   { TGLLightSetEditor *p; p=(TGLLightSetEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLightSet),-1,-1,2,"fM=",0,"fModel dynamic-casted to TGLLightSetEditor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor),-1,-1,2,"fSE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLOverlayButton */
static void G__setup_memvarTGLOverlayButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton));
   { TGLOverlayButton *p; p=(TGLOverlayButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,2,"fText=",0,"button text");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActiveID=",0,"active item identifier");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fBackColor=",0,"button background color");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-1,2,"fTextColor=",0,"text color");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fNormAlpha=",0,"button alpha value (transparency) in normal state");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fHighAlpha=",0,"button alpha value (transparency) in highlight state");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPosX=",0,"button x position");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPosY=",0,"button y position");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWidth=",0,"button width");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fHeight=",0,"button height");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFont),-1,-1,2,"fFont=",0,"font used to render text");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLParametricEquationGL */
static void G__setup_memvarTGLParametricEquationGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL));
   { TGLParametricEquationGL *p; p=(TGLParametricEquationGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLParametricPlot */
static void G__setup_memvarTGLParametricPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot));
   { TGLParametricPlot *p; p=(TGLParametricPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlotcLcLEMeshSize),-1,-2,4,"kLow=30LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlotcLcLEMeshSize),-1,-2,4,"kHigh=150LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMeshSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylETGLParametricPlotcLcLVertex_tgR),G__defined_typename("TGL2DArray<Vertex_t>"),-1,4,"fMesh=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShowMesh=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColorScheme=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation),-1,-1,4,"fEquation=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPolyLine */
static void G__setup_memvarTGLPolyLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPolyLine));
   { TGLPolyLine *p; p=(TGLPolyLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVertices=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLineWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPolyMarker */
static void G__setup_memvarTGLPolyMarker(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPolyMarker));
   { TGLPolyMarker *p; p=(TGLPolyMarker*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVertices=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLPShapeObjEditor */
static void G__setup_memvarTGLPShapeObjEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor));
   { TGLPShapeObjEditor *p; p=(TGLPShapeObjEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditorcLcLELightMode),-1,-2,4,"kDiffuse=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditorcLcLELightMode),-1,-2,4,"kAmbient=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditorcLcLELightMode),-1,-2,4,"kSpecular=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditorcLcLELightMode),-1,-2,4,"kEmission=3LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditorcLcLELightMode),-1,-1,4,"fLMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLayoutHints),-1,-1,4,"fLb=",0,"button layout");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLayoutHints),-1,-1,4,"fLe=",0,"num entry layout");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLayoutHints),-1,-1,4,"fLl=",0,"label layout");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLayoutHints),-1,-1,4,"fLs=",0,"slider layout");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fGeoFrame=",0,"orientation, clipping");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry),-1,-1,4,"fGeomData[6]=",0,"position and clipping control");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,4,"fGeoApplyButton=",0,"action button");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fColorFrame=",0,"top frame for color componet control");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLWidget),-1,-1,4,"fMatView=",0,"inner structure to handle sphere GL window");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,4,"fLightTypes[4]=",0,"light type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGHSlider),-1,-1,4,"fRedSlider=",0,"red component of selected material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGHSlider),-1,-1,4,"fGreenSlider=",0,"green component of selected material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGHSlider),-1,-1,4,"fBlueSlider=",0,"blue component of selected material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGHSlider),-1,-1,4,"fAlphaSlider=",0,"alpha component of selected material lider;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGHSlider),-1,-1,4,"fShineSlider=",0,"specular refelction of selected material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,4,"fColorApplyButton=",0,"apply to selected");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,4,"fColorApplyFamily=",0,"apply to selected and family");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRGBA[17]=",0,"color multiplet");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Window_t"),-1,4,"fGLWin=",0,"GL window with sphere");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,4,"fCtx=",0,"GL context");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj),-1,-1,4,"fPShapeObj=",0,"model");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLRotateManip */
static void G__setup_memvarTGLRotateManip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip));
   { TGLRotateManip *p; p=(TGLRotateManip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShallowRing=",0,"! does active ring form shallow angle to eye?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShallowFront=",0,"! front or back of the active shallow ring?");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLPlane),-1,-1,4,"fActiveRingPlane=",0,"! plane of the active ring (widget)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVertex3),-1,-1,4,"fActiveRingCenter=",0,"! center of active ring");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLine3),-1,-1,4,"fRingLine=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLine3),-1,-1,4,"fRingLineOld=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSAViewer */
static void G__setup_memvarTGLSAViewer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer));
   { TGLSAViewer *p; p=(TGLSAViewer*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLHelpAbout=%lldLL",(long long)TGLSAViewer::kGLHelpAbout).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLHelpViewer=%lldLL",(long long)TGLSAViewer::kGLHelpViewer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLPerspYOZ=%lldLL",(long long)TGLSAViewer::kGLPerspYOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLPerspXOZ=%lldLL",(long long)TGLSAViewer::kGLPerspXOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLPerspXOY=%lldLL",(long long)TGLSAViewer::kGLPerspXOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLXOY=%lldLL",(long long)TGLSAViewer::kGLXOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLXOZ=%lldLL",(long long)TGLSAViewer::kGLXOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLZOY=%lldLL",(long long)TGLSAViewer::kGLZOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLXnOY=%lldLL",(long long)TGLSAViewer::kGLXnOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLXnOZ=%lldLL",(long long)TGLSAViewer::kGLXnOZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLZnOY=%lldLL",(long long)TGLSAViewer::kGLZnOY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLOrthoRotate=%lldLL",(long long)TGLSAViewer::kGLOrthoRotate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLOrthoDolly=%lldLL",(long long)TGLSAViewer::kGLOrthoDolly).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSaveEPS=%lldLL",(long long)TGLSAViewer::kGLSaveEPS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSavePDF=%lldLL",(long long)TGLSAViewer::kGLSavePDF).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSavePNG=%lldLL",(long long)TGLSAViewer::kGLSavePNG).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSaveGIF=%lldLL",(long long)TGLSAViewer::kGLSaveGIF).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSaveAnimGIF=%lldLL",(long long)TGLSAViewer::kGLSaveAnimGIF).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSaveJPG=%lldLL",(long long)TGLSAViewer::kGLSaveJPG).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLSaveAS=%lldLL",(long long)TGLSAViewer::kGLSaveAS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLCloseViewer=%lldLL",(long long)TGLSAViewer::kGLCloseViewer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLQuitROOT=%lldLL",(long long)TGLSAViewer::kGLQuitROOT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLEditObject=%lldLL",(long long)TGLSAViewer::kGLEditObject).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewercLcLEGLSACommands),-1,-2,1,G__FastAllocString(2048).Format("kGLHideMenus=%lldLL",(long long)TGLSAViewer::kGLHideMenus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame),-1,-1,4,"fFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFormat),-1,-1,4,"fFormat=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGPopupMenu),-1,-1,4,"fFileMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGPopupMenu),-1,-1,4,"fFileSaveMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGPopupMenu),-1,-1,4,"fCameraMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGPopupMenu),-1,-1,4,"fHelpMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fLeftVerticalFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame),-1,-1,4,"fRightVerticalFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fDirName=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTypeIdx=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fOverwrite=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGMenuBar),-1,-1,4,"fMenuBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGButton),-1,-1,4,"fMenuBut=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHideMenuBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TTimer),-1,-1,4,"fMenuHidingTimer=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMenuHidingShowMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDeleteMenuBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgMenuHidingTimeout=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgInitX=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgInitY=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgInitW=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgInitH=0LL",0,(char*)NULL);
   G__memvar_setup((void*)0,67,0,1,-1,-1,-2,4,"fgHelpText1=",0,(char*)NULL);
   G__memvar_setup((void*)0,67,0,1,-1,-1,-2,4,"fgHelpText2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSAFrame */
static void G__setup_memvarTGLSAFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame));
   { TGLSAFrame *p; p=(TGLSAFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer),-1,-1,4,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLScaleManip */
static void G__setup_memvarTGLScaleManip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip));
   { TGLScaleManip *p; p=(TGLScaleManip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLVector3),-1,-1,4,"fStartScale=",0,"! initial scaling factors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLScene::TSceneInfo */
static void G__setup_memvarTGLScenecLcLTSceneInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo));
   { TGLScene::TSceneInfo *p; p=(TGLScene::TSceneInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fShapesOfInterest)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR),G__defined_typename("ShapeVec_t"),-1,1,"fShapesOfInterest=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fVisibleElements)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR),G__defined_typename("DrawElementVec_t"),-1,1,"fVisibleElements=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMinorStamp)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fMinorStamp=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fOpaqueElements)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),G__defined_typename("DrawElementPtrVec_t"),-1,1,"fOpaqueElements=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTranspElements)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),G__defined_typename("DrawElementPtrVec_t"),-1,1,"fTranspElements=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSelOpaqueElements)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),G__defined_typename("DrawElementPtrVec_t"),-1,1,"fSelOpaqueElements=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSelTranspElements)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR),G__defined_typename("DrawElementPtrVec_t"),-1,1,"fSelTranspElements=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fOpaqueCnt)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fOpaqueCnt=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTranspCnt)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fTranspCnt=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fAsPixelCnt)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fAsPixelCnt=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fByShapeCnt)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR),G__defined_typename("map<TClass*,UInt_t>"),-1,1,"fByShapeCnt=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLScenePad */
static void G__setup_memvarTGLScenePad(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad));
   { TGLScenePad *p; p=(TGLScenePad*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TVirtualPad),-1,-1,2,"fPad=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInternalPIDs=",0,"! using internal physical IDs");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNextInternalPID=",0,"! next internal physical ID (from 1 - 0 reserved)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLastPID=",0,"! last physical ID that was processed in AddObject()");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fAcceptedPhysicals=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet),-1,-1,2,"fComposite=",0,"! Paritally created composite");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCSLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR),G__defined_typename("vector<CSPart_t>"),-1,2,"fCSTokens=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmartRefresh=",0,"! cache logicals during scene rebuilds");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSphere */
static void G__setup_memvarTGLSphere(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSphere));
   { TGLSphere *p; p=(TGLSphere*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRadius=",0,"Sphere radius");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLSurfacePainter */
static void G__setup_memvarTGLSurfacePainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter));
   { TGLSurfacePainter *p; p=(TGLSurfacePainter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-2,4,"kSurf=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-2,4,"kSurf1=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-2,4,"kSurf2=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-2,4,"kSurf3=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-2,4,"kSurf4=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-2,4,"kSurf5=5LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType),-1,-1,4,"fType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylETGLVertex3gR),-1,-1,4,"fMesh=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylEdoublegR),G__defined_typename("TGL2DArray<Double_t>"),-1,4,"fTexMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylEpairlETGLVector3cOTGLVector3gRsPgR),G__defined_typename("TGL2DArray<std::pair<TGLVector3,TGLVector3> >"),-1,4,"fFaceNormals=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGL2DArraylETGLVector3gR),-1,-1,4,"fAverageNormals=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TString),-1,-1,4,"fObjectInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePaintercLcLProjection_t),-1,-1,4,"fProj=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR),G__defined_typename("list<Projection_t>"),-1,4,"fXOZProj=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR),G__defined_typename("list<Projection_t>"),-1,4,"fYOZProj=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR),G__defined_typename("list<Projection_t>"),-1,4,"fXOYProj=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLevelPalette),-1,-1,4,"fPalette=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fColorLevels=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fMinMaxVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSectionPass=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUpdateTexMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TRandom),-1,-2,4,"fgRandom=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLTF3Painter */
static void G__setup_memvarTGLTF3Painter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter));
   { TGLTF3Painter *p; p=(TGLTF3Painter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTF3PaintercLcLETF3Style),-1,-2,4,"kDefault=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTF3PaintercLcLETF3Style),-1,-2,4,"kMaple0=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTF3PaintercLcLETF3Style),-1,-2,4,"kMaple1=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__GLLN_TGLTF3PaintercLcLETF3Style),-1,-2,4,"kMaple2=3LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTF3PaintercLcLETF3Style),-1,-1,4,"fStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_RglcLcLMccLcLTIsoMeshlEdoublegR),-1,-1,4,"fMesh=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TF3),-1,-1,4,"fF3=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fXOZSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fYOZSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fXOYSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLIsoPainter */
static void G__setup_memvarTGLIsoPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   { TGLIsoPainter *p; p=(TGLIsoPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fXOZSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fYOZSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice),-1,-1,4,"fXOYSlice=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_RglcLcLMccLcLTIsoMeshlEfloatgR),G__defined_typename("Mesh_t"),-1,4,"fDummyMesh=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR),G__defined_typename("MeshList_t"),-1,4,"fIsos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR),G__defined_typename("MeshList_t"),-1,4,"fCache=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("Range_t"),-1,4,"fMinMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLLevelPalette),-1,-1,4,"fPalette=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fColorLevels=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLTH3CompositionPainter */
static void G__setup_memvarTGLTH3CompositionPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter));
   { TGLTH3CompositionPainter *p; p=(TGLTH3CompositionPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition),-1,-1,4,"fData=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR),G__defined_typename("pair<Double_t,Double_t>"),-1,4,"fMinMaxVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GLLN_TGLQuadric),-1,-1,4,"fQuadric=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGLTransManip */
static void G__setup_memvarTGLTransManip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTransManip));
   { TGLTransManip *p; p=(TGLTransManip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2GL */
static void G__setup_memvarTH2GL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TH2GL));
   { TH2GL *p; p=(TH2GL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TH2),-1,-1,2,"fM=",0,"Model object dynamic-casted to TH2.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3GL */
static void G__setup_memvarTH3GL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TH3GL));
   { TH3GL *p; p=(TH3GL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TH3),-1,-1,2,"fM=",0,"Model object dynamic-casted to TH2.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPointSet3DGL */
static void G__setup_memvarTPointSet3DGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL));
   { TPointSet3DGL *p; p=(TPointSet3DGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TX11GLManager */
static void G__setup_memvarTX11GLManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GLLN_TX11GLManager));
   { TX11GLManager *p; p=(TX11GLManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TX11GLManagercLcLTX11GLImpl),-1,-1,4,"fPimpl=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GLLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__GL() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTArcBall(void) {
   /* TArcBall */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TArcBall));
   G__memfunc_setup("TArcBall",741,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TArcBall), -1, 0, 1, 1, 4, 0, "u 'TArcBall' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TArcBall), -1, 1, 1, 1, 4, 0, "u 'TArcBall' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetMatrices",1339,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MapToSphere",1096,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'TPoint' - 11 - NewPt D - 'Double_t' 0 - NewVec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArcBall",741,G__G__GL_100_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TArcBall), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 '100' NewWidth h - 'UInt_t' 0 '100' NewHeight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBounds",919,G__G__GL_100_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - NewWidth h - 'UInt_t' 0 - NewHeight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Click",486,G__G__GL_100_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TPoint' - 11 - NewPt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Drag",382,G__G__GL_100_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TPoint' - 11 - NewPt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRotMatrix",1226,G__G__GL_100_0_9, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_100_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArcBall::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_100_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArcBall::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_100_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArcBall::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_100_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArcBall::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_100_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_100_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_100_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_100_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__GL_100_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArcBall::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_100_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArcBall::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_100_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArcBall::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_100_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArcBall::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArcBall", 867, G__G__GL_100_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLBoundingBox(void) {
   /* TGLBoundingBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox));
   G__memfunc_setup("UpdateCache",1079,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidIndex",1000,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Min",292,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Max",294,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLBoundingBox",1350,G__G__GL_102_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLBoundingBox",1350,G__G__GL_102_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 0, 1, 1, 1, 0, "U 'TGLVertex3' - 10 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLBoundingBox",1350,G__G__GL_102_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLBoundingBox",1350,G__G__GL_102_0_8, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - lowVertex u 'TGLVertex3' - 11 - highVertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLBoundingBox",1350,G__G__GL_102_0_9, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_102_0_10, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 1, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_102_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLVertex3' - 10 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_102_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_102_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmpty",827,G__G__GL_102_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAligned",992,G__G__GL_102_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - lowVertex u 'TGLVertex3' - 11 - highVertex", "axis aligned", (void*) NULL, 0);
   G__memfunc_setup("SetAligned",992,G__G__GL_102_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbPnts D - 'Double_t' 10 - pnts", "axis aligned", (void*) NULL, 0);
   G__memfunc_setup("MergeAligned",1188,G__G__GL_102_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExpandAligned",1300,G__G__GL_102_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Transform",956,G__G__GL_102_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__GL_102_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__GL_102_0_21, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - xFactor d - 'Double_t' 0 - yFactor "
"d - 'Double_t' 0 - zFactor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Translate",942,G__G__GL_102_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 11 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__GL_102_0_23, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Vertex",638,G__G__GL_102_0_24, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XMin",380,G__G__GL_102_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XMax",382,G__G__GL_102_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("YMin",381,G__G__GL_102_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("YMax",383,G__G__GL_102_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZMin",382,G__G__GL_102_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZMax",384,G__G__GL_102_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinAAVertex",1060,G__G__GL_102_0_31, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MaxAAVertex",1062,G__G__GL_102_0_32, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Vertices",837,G__G__GL_102_0_33, 85, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 9, "", "All 8 box vertices", (void*) NULL, 0);
   G__memfunc_setup("NumVertices",1141,G__G__GL_102_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FaceVertices",1204,G__G__GL_102_0_35, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<UInt_t>"), 1, 1, 1, 1, 9, "i 'TGLBoundingBox::EFace' - 0 - face", "4 box face vertices", (void*) NULL, 0);
   G__memfunc_setup("Center",609,G__G__GL_102_0_36, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Extents",747,G__G__GL_102_0_37, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Axis",405,G__G__GL_102_0_38, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 2, 1, 1, 9, 
"h - 'UInt_t' 0 - i g - 'Bool_t' 0 'kTRUE' normalised", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEmpty",715,G__G__GL_102_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Volume",632,G__G__GL_102_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Diagonal",799,G__G__GL_102_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PlaneSet",796,G__G__GL_102_0_42, 121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 1 - planeSet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNearPlane",1174,G__G__GL_102_0_43, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Overlap",729,G__G__GL_102_0_44, 105, G__get_linked_tagnum(&G__G__GLLN_EOverlap), -1, 0, 1, 1, 1, 8, "u 'TGLPlane' - 11 - plane", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Overlap",729,G__G__GL_102_0_45, 105, G__get_linked_tagnum(&G__G__GLLN_EOverlap), -1, 0, 1, 1, 1, 8, "u 'TGLBoundingBox' - 11 - box", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,G__G__GL_102_0_46, 121, -1, -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' solid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__GL_102_0_47, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_102_0_48, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLBoundingBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_102_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoundingBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_102_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLBoundingBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_102_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLBoundingBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_102_0_52, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_102_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_102_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_102_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_102_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoundingBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_102_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBoundingBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_102_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoundingBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_102_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBoundingBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLBoundingBox", 1476, G__G__GL_102_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLCamera(void) {
   /* TGLCamera */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCamera));
   G__memfunc_setup("Frustum",758,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 0, 1, 1, 4, 8, "g - 'Bool_t' 0 'kTRUE' asBox", "current frustum", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 1, 1, 1, 4, 0, "u 'TGLCamera' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateCache",1079,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOrthographic",1446,G__G__GL_103_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsPerspective",1350,G__G__GL_103_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RefModelViewMatrix",1822,G__G__GL_103_0_9, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCacheDirty",1180,G__G__GL_103_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncTimeStamp",1198,G__G__GL_103_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TimeStamp",916,G__G__GL_103_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewport",1164,G__G__GL_103_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRect' - 11 - viewport", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefViewport",1149,G__G__GL_103_0_14, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefViewport",1149,G__G__GL_103_0_15, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Setup",529,G__G__GL_103_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLBoundingBox' - 11 - box g - 'Bool_t' 0 'kTRUE' reset", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Reset",515,G__G__GL_103_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Dolly",516,G__G__GL_103_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - delta g - 'Bool_t' 0 - mod1 "
"g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zoom",421,G__G__GL_103_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - delta g - 'Bool_t' 0 - mod1 "
"g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Truck",521,G__G__GL_103_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xDelta d - 'Double_t' 0 - yDelta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Truck",521,G__G__GL_103_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Rotate",623,G__G__GL_103_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateRad",902,G__G__GL_103_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - hRotate d - 'Double_t' 0 - vRotate", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,G__G__GL_103_0_24, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TGLBoundingBox' - 11 - sceneBox U 'TGLRect' - 10 '0' pickRect", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AdjustAndClampVal",1678,G__G__GL_103_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 1, 8, 
"d - 'Double_t' 1 - val d - 'Double_t' 0 - min "
"d - 'Double_t' 0 - max i - 'Int_t' 0 - screenShift "
"i - 'Int_t' 0 - screenShiftRange g - 'Bool_t' 0 - mod1 "
"g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustDelta",1109,G__G__GL_103_0_26, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 0 - screenShift d - 'Double_t' 0 - deltaFactor "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExternalCenter",1744,G__G__GL_103_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExternalCenter",1732,G__G__GL_103_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCenterVec",1195,G__G__GL_103_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCenterVecWarp",1605,G__G__GL_103_0_30, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCenterVec",1183,G__G__GL_103_0_31, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixDefCenter",1475,G__G__GL_103_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixDefCenterVec",1761,G__G__GL_103_0_33, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixDefCenterVec",1749,G__G__GL_103_0_34, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNearClip",1070,G__G__GL_103_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFarClip",961,G__G__GL_103_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCamBase",940,G__G__GL_103_0_37, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCamTrans",1081,G__G__GL_103_0_38, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefCamBase",937,G__G__GL_103_0_39, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefCamTrans",1078,G__G__GL_103_0_40, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta",790,G__G__GL_103_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefLastNoPickProjM",1757,G__G__GL_103_0_42, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EyePoint",813,G__G__GL_103_0_43, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EyeDirection",1220,G__G__GL_103_0_44, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FrustumCenter",1367,G__G__GL_103_0_45, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FrustumPlane",1254,G__G__GL_103_0_46, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 1, 1, 1, 1, 9, "i 'TGLCamera::EFrustumPlane' - 0 - plane", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FrustumOverlap",1487,G__G__GL_103_0_47, 105, G__get_linked_tagnum(&G__G__GLLN_EOverlap), -1, 0, 1, 1, 1, 8, "u 'TGLBoundingBox' - 11 - box", "box/frustum overlap test", (void*) NULL, 0);
   G__memfunc_setup("ViewportOverlap",1593,G__G__GL_103_0_48, 105, G__get_linked_tagnum(&G__G__GLLN_EOverlap), -1, 0, 1, 1, 1, 8, "u 'TGLBoundingBox' - 11 - box", "box/viewport overlap test", (void*) NULL, 0);
   G__memfunc_setup("ViewportRect",1262,G__G__GL_103_0_49, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 0, 2, 1, 1, 8, 
"u 'TGLBoundingBox' - 11 - box i 'TGLBoundingBox::EFace' - 0 - face", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportRect",1262,G__G__GL_103_0_50, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 0, 2, 1, 1, 8, 
"u 'TGLBoundingBox' - 11 - box I 'TGLBoundingBox::EFace' - 10 '0' face", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WorldToViewport",1579,G__G__GL_103_0_51, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 2, 1, 1, 8, 
"u 'TGLVertex3' - 11 - worldVertex U 'TGLMatrix' - 0 '0' modviewMat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WorldDeltaToViewport",2069,G__G__GL_103_0_52, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 2, 1, 1, 8, 
"u 'TGLVertex3' - 11 - worldRef u 'TGLVector3' - 11 - worldDelta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportToWorld",1579,G__G__GL_103_0_53, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 2, 1, 1, 8, 
"u 'TGLVertex3' - 11 - viewportVertex U 'TGLMatrix' - 0 '0' modviewMat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportToWorld",1579,G__G__GL_103_0_54, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - viewportX d - 'Double_t' 0 - viewportY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportToWorld",1579,G__G__GL_103_0_55, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 0, 1, 1, 1, 8, "u 'TPoint' - 11 - viewport", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportDeltaToWorld",2069,G__G__GL_103_0_56, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 4, 1, 1, 8, 
"u 'TGLVertex3' - 11 - worldRef d - 'Double_t' 0 - viewportXDelta "
"d - 'Double_t' 0 - viewportYDelta U 'TGLMatrix' - 0 '0' modviewMat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportPlaneIntersection",2631,G__G__GL_103_0_57, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEboolcOTGLVertex3gR), G__defined_typename("pair<Bool_t,TGLVertex3>"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - viewportX d - 'Double_t' 0 - viewportY "
"u 'TGLPlane' - 11 - worldPlane", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportPlaneIntersection",2631,G__G__GL_103_0_58, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEboolcOTGLVertex3gR), G__defined_typename("pair<Bool_t,TGLVertex3>"), 0, 2, 1, 1, 8, 
"u 'TPoint' - 11 - viewport u 'TGLPlane' - 11 - worldPlane", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowToViewport",1691,G__G__GL_103_0_59, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 1 - - i - 'Int_t' 1 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowToViewport",1691,G__G__GL_103_0_60, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TPoint' - 1 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowToViewport",1691,G__G__GL_103_0_61, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRect' - 1 - rect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowToViewport",1691,G__G__GL_103_0_62, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLVertex3' - 1 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVAxisMinAngle",1558,G__G__GL_103_0_63, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVAxisMinAngle",1570,G__G__GL_103_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Configure",930,G__G__GL_103_0_65, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - zoom d - 'Double_t' 0 - dolly "
"D - 'Double_t' 0 - center d - 'Double_t' 0 - hRotate "
"d - 'Double_t' 0 - vRotate", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("OfInterest",1027,G__G__GL_103_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"u 'TGLBoundingBox' - 11 - box g - 'Bool_t' 0 - ignoreSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateInterest",1457,G__G__GL_103_0_67, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetInterest",1361,G__G__GL_103_0_68, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawDebugAids",1270,G__G__GL_103_0_69, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_103_0_70, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLCamera::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_103_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCamera::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_103_0_72, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLCamera::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_103_0_73, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLCamera::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_103_0_74, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_103_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_103_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_103_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_103_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCamera::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_103_0_79, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCamera::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_103_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCamera::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_103_0_81, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCamera::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLCamera", 942, G__G__GL_103_0_82, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLVector3(void) {
   /* TGLVector3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLVector3));
   G__memfunc_setup("TGLVector3",909,G__G__GL_113_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVector3",909,G__G__GL_113_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVector3",909,G__G__GL_113_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVector3",909,G__G__GL_113_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_113_0_5, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__GL_113_0_6, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__GL_113_0_7, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag",277,G__G__GL_113_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Normalise",938,G__G__GL_113_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_113_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLVector3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_113_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVector3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_113_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLVector3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_113_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLVector3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_113_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__GL_113_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVector3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_113_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVector3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_113_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVector3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_113_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVector3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLVector3", 1035, G__G__GL_113_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_113_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 1, 1, 1, 0, "u 'TGLVector3' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLVertex3(void) {
   /* TGLVertex3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLVertex3));
   G__memfunc_setup("ValidIndex",1000,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVertex3",920,G__G__GL_114_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVertex3",920,G__G__GL_114_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVertex3",920,G__G__GL_114_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLVertex3",920,G__G__GL_114_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__GL_114_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLVertex3' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_114_0_7, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__GL_114_0_8, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__GL_114_0_9, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__GL_114_0_10, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 1, 1, 1, 1, "u 'TGLVector3' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__GL_114_0_11, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 1, 1, 1, 1, "u 'TGLVector3' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__GL_114_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_114_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_114_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - xyz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_114_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shift",510,G__G__GL_114_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 1 - shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shift",510,G__G__GL_114_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - xDelta d - 'Double_t' 0 - yDelta "
"d - 'Double_t' 0 - zDelta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Negate",596,G__G__GL_114_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimum",732,G__G__GL_114_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Maximum",734,G__G__GL_114_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__GL_114_0_21, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__GL_114_0_22, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 9, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__G__GL_114_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__G__GL_114_0_24, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__G__GL_114_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__G__GL_114_0_26, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__G__GL_114_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__G__GL_114_0_28, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CArr",360,G__G__GL_114_0_29, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__GL_114_0_30, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__GL_114_0_31, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_114_0_32, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLVertex3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_114_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVertex3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_114_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLVertex3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_114_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLVertex3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_114_0_36, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_114_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_114_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_114_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__GL_114_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVertex3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_114_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVertex3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_114_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLVertex3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_114_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLVertex3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLVertex3", 1046, G__G__GL_114_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLine3(void) {
   /* TGLLine3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLine3));
   G__memfunc_setup("TGLLine3",674,G__G__GL_115_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - start u 'TGLVertex3' - 11 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLLine3",674,G__G__GL_115_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - start u 'TGLVector3' - 11 - vector", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_115_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - start u 'TGLVertex3' - 11 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_115_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - start u 'TGLVector3' - 11 - vector", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Start",526,G__G__GL_115_0_5, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("End",279,G__G__GL_115_0_6, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Vector",627,G__G__GL_115_0_7, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,G__G__GL_115_0_8, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_115_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLine3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_115_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLine3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_115_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLine3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_115_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLine3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_115_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_115_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_115_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_115_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__GL_115_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLine3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_115_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLine3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_115_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLine3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_115_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLine3::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLLine3", 674, G__G__GL_115_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 0, 1, 1, 1, 0, "u 'TGLLine3' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLLine3", 800, G__G__GL_115_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_115_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 1, 1, 1, 1, 0, "u 'TGLLine3' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLRect(void) {
   /* TGLRect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRect));
   G__memfunc_setup("TGLRect",629,G__G__GL_116_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLRect",629,G__G__GL_116_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - width i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLRect",629,G__G__GL_116_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -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, 0);
   G__memfunc_setup("Set",300,G__G__GL_116_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - width i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCorner",917,G__G__GL_116_0_5, 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("Offset",615,G__G__GL_116_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - dX i - 'Int_t' 0 - dY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Expand",608,G__G__GL_116_0_7, 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("CArr",360,G__G__GL_116_0_8, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CArr",360,G__G__GL_116_0_9, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__G__GL_116_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__G__GL_116_0_11, 105, -1, G__defined_typename("Int_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__G__GL_116_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__G__GL_116_0_13, 105, -1, G__defined_typename("Int_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Width",512,G__G__GL_116_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Width",512,G__G__GL_116_0_15, 105, -1, G__defined_typename("Int_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Height",601,G__G__GL_116_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Height",601,G__G__GL_116_0_17, 105, -1, G__defined_typename("Int_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CenterX",697,G__G__GL_116_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CenterY",698,G__G__GL_116_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Left",395,G__G__GL_116_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Right",510,G__G__GL_116_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Top",307,G__G__GL_116_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Bottom",629,G__G__GL_116_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Diagonal",799,G__G__GL_116_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Longest",732,G__G__GL_116_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Aspect",608,G__G__GL_116_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Overlap",729,G__G__GL_116_0_27, 105, G__get_linked_tagnum(&G__G__GLLN_EOverlap), -1, 0, 1, 1, 1, 8, "u 'TGLRect' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_116_0_28, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLRect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_116_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_116_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLRect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_116_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLRect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_116_0_32, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_116_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_116_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_116_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_116_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_116_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLRect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_116_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_116_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLRect::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLRect", 629, G__G__GL_116_0_40, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 0, 1, 1, 1, 0, "u 'TGLRect' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLRect", 755, G__G__GL_116_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_116_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 1, 1, 1, 1, 0, "u 'TGLRect' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPlane(void) {
   /* TGLPlane */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlane));
   G__memfunc_setup("Normalise",938,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlane",727,G__G__GL_117_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlane",727,G__G__GL_117_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 1, 1, 1, 0, "u 'TGLPlane' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlane",727,G__G__GL_117_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlane",727,G__G__GL_117_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - eq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlane",727,G__G__GL_117_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 2, 1, 1, 0, 
"u 'TGLVector3' - 11 - norm u 'TGLVertex3' - 11 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlane",727,G__G__GL_117_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 0, 3, 1, 1, 0, 
"u 'TGLVertex3' - 11 - p1 u 'TGLVertex3' - 11 - p2 "
"u 'TGLVertex3' - 11 - p3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_117_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLPlane' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_117_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_117_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - eq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_117_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVector3' - 11 - norm u 'TGLVertex3' - 11 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_117_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLVertex3' - 11 - p1 u 'TGLVertex3' - 11 - p2 "
"u 'TGLVertex3' - 11 - p3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Negate",596,G__G__GL_117_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("A",65,G__G__GL_117_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("B",66,G__G__GL_117_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("C",67,G__G__GL_117_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("D",68,G__G__GL_117_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm",412,G__G__GL_117_0_18, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistanceTo",1006,G__G__GL_117_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'TGLVertex3' - 11 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NearestOn",911,G__G__GL_117_0_20, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 1, 1, 1, 8, "u 'TGLVertex3' - 11 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CArr",360,G__G__GL_117_0_21, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__GL_117_0_22, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__GL_117_0_23, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_117_0_24, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPlane::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_117_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlane::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_117_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPlane::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_117_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPlane::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_117_0_28, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_117_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_117_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_117_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_117_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlane::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_117_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlane::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_117_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlane::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_117_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlane::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPlane", 853, G__G__GL_117_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_117_0_37, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 1, 1, 1, 1, 0, "u 'TGLPlane' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLMatrix(void) {
   /* TGLMatrix */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLMatrix));
   G__memfunc_setup("ValidIndex",1000,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "h - 'UInt_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - translation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 3, 1, 1, 0, 
"u 'TGLVertex3' - 11 - origin u 'TGLVector3' - 11 - zAxis "
"u 'TGLVector3' - 11 - xAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 2, 1, 1, 0, 
"u 'TGLVertex3' - 11 - origin u 'TGLVector3' - 11 - zAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - vals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLMatrix",860,G__G__GL_124_0_8, 105, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 0, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_124_0_9, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__GL_124_0_10, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__GL_124_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultRight",928,G__G__GL_124_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultLeft",813,G__G__GL_124_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - lhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__GL_124_0_14, 117, G__get_linked_tagnum(&G__G__GLLN_TGLMatrix), -1, 1, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_124_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLVertex3' - 11 - origin u 'TGLVector3' - 11 - zAxis "
"u 'TGLVector3' - 11 '0' xAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_124_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - vals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIdentity",1142,G__G__GL_124_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__GL_124_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__GL_124_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - translation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Translate",942,G__G__GL_124_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 11 - vect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveLF",553,G__G__GL_124_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ai d - 'Double_t' 0 - amount", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Move3LF",604,G__G__GL_124_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__GL_124_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 11 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rotate",623,G__G__GL_124_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLVertex3' - 11 - pivot u 'TGLVector3' - 11 - axis "
"d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateLF",769,G__G__GL_124_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i1 i - 'Int_t' 0 - i2 "
"d - 'Double_t' 0 - amount", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotatePF",773,G__G__GL_124_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i1 i - 'Int_t' 0 - i2 "
"d - 'Double_t' 0 - amount", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TransformVertex",1594,G__G__GL_124_0_27, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLVertex3' - 1 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Transpose3x3",1181,G__G__GL_124_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__GL_124_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTranslation",1455,G__G__GL_124_0_30, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__GL_124_0_31, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaseVec",965,G__G__GL_124_0_32, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - b d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaseVec",965,G__G__GL_124_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - b u 'TGLVector3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaseVec",965,G__G__GL_124_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - b D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseVec",953,G__G__GL_124_0_35, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseVec",953,G__G__GL_124_0_36, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - b u 'TGLVector3' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseVec",953,G__G__GL_124_0_37, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - b D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Multiply",864,G__G__GL_124_0_38, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 2, 1, 1, 8, 
"u 'TGLVector3' - 11 - v d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rotate",623,G__G__GL_124_0_39, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 1, 1, 1, 8, "u 'TGLVector3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultiplyIP",1017,G__G__GL_124_0_40, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TGLVector3' - 1 - v d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateIP",776,G__G__GL_124_0_41, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLVector3' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CArr",360,G__G__GL_124_0_42, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__GL_124_0_43, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__GL_124_0_44, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_124_0_45, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLMatrix::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_124_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLMatrix::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_124_0_47, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLMatrix::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_124_0_48, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLMatrix::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_124_0_49, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_124_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_124_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_124_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_124_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLMatrix::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_124_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLMatrix::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_124_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLMatrix::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_124_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLMatrix::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLMatrix", 986, G__G__GL_124_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLColor(void) {
   /* TGLColor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLColor));
   G__memfunc_setup("TGLColor",742,G__G__GL_125_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLColor",742,G__G__GL_125_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - r i - 'Int_t' 0 - g "
"i - 'Int_t' 0 - b i - 'Int_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLColor",742,G__G__GL_125_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b f - 'Float_t' 0 '1' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLColor",742,G__G__GL_125_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color_index c - 'Char_t' 0 '0' transparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_125_0_5, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 1, 1, 1, 0, "u 'TGLColor' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__GL_125_0_6, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CArr",360,G__G__GL_125_0_7, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRed",571,G__G__GL_125_0_8, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGreen",785,G__G__GL_125_0_9, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlue",680,G__G__GL_125_0_10, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha",774,G__G__GL_125_0_11, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColorIndex",1303,G__G__GL_125_0_12, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransparency",1562,G__G__GL_125_0_13, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRed",583,G__G__GL_125_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGreen",797,G__G__GL_125_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBlue",692,G__G__GL_125_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlpha",786,G__G__GL_125_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColor",811,G__G__GL_125_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - r i - 'Int_t' 0 - g "
"i - 'Int_t' 0 - b i - 'Int_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColor",811,G__G__GL_125_0_19, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b f - 'Float_t' 0 '1' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColor",811,G__G__GL_125_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color_index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColor",811,G__G__GL_125_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color_index c - 'Char_t' 0 - transparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransparency",1574,G__G__GL_125_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - transparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AsString",811,G__G__GL_125_0_23, 117, G__get_linked_tagnum(&G__G__GLLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_125_0_24, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLColor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_125_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLColor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_125_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLColor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_125_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLColor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_125_0_28, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_125_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_125_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_125_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_125_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLColor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_125_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLColor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_125_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLColor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_125_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLColor::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLColor", 742, G__G__GL_125_0_36, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 0, 1, 1, 1, 0, "u 'TGLColor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLColor", 868, G__G__GL_125_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLColorSet(void) {
   /* TGLColorSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLColorSet));
   G__memfunc_setup("TGLColorSet",1042,G__G__GL_126_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_126_0_2, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 1, 1, 1, 1, 0, "u 'TGLColorSet' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Background",1024,G__G__GL_126_0_3, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Foreground",1051,G__G__GL_126_0_4, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Outline",736,G__G__GL_126_0_5, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Markup",624,G__G__GL_126_0_6, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Selection",934,G__G__GL_126_0_7, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Background",1024,G__G__GL_126_0_8, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Foreground",1051,G__G__GL_126_0_9, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Outline",736,G__G__GL_126_0_10, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Markup",624,G__G__GL_126_0_11, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Selection",934,G__G__GL_126_0_12, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColor), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StdDarkBackground",1709,G__G__GL_126_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StdLightBackground",1827,G__G__GL_126_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_126_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLColorSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_126_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLColorSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_126_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLColorSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_126_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLColorSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_126_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_126_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_126_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_126_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__GL_126_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLColorSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_126_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLColorSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_126_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLColorSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_126_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLColorSet::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLColorSet", 1042, G__G__GL_126_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 0, 1, 1, 1, 0, "u 'TGLColorSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLColorSet", 1168, G__G__GL_126_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLUtil(void) {
   /* TGLUtil */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtil));
   G__memfunc_setup("TGLUtil",645,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLUtil), -1, 0, 1, 1, 4, 0, "u 'TGLUtil' - 11 - -", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLUtil), -1, 1, 1, 1, 4, 0, "u 'TGLUtil' - 11 - -", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("CheckError",1000,G__G__GL_127_0_3, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - loc", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TGLUtil::CheckError) ), 0);
   G__memfunc_setup("GetDrawTesselator3fv",2019,G__G__GL_127_0_4, 85, G__get_linked_tagnum(&G__G__GLLN_GLUtesselator), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (GLUtesselator* (*)())(&TGLUtil::GetDrawTesselator3fv) ), 0);
   G__memfunc_setup("GetDrawTesselator4fv",2020,G__G__GL_127_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_GLUtesselator), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (GLUtesselator* (*)())(&TGLUtil::GetDrawTesselator4fv) ), 0);
   G__memfunc_setup("GetDrawTesselator3dv",2017,G__G__GL_127_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_GLUtesselator), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (GLUtesselator* (*)())(&TGLUtil::GetDrawTesselator3dv) ), 0);
   G__memfunc_setup("GetDrawTesselator4dv",2018,G__G__GL_127_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_GLUtesselator), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (GLUtesselator* (*)())(&TGLUtil::GetDrawTesselator4dv) ), 0);
   G__memfunc_setup("GetDrawQuality",1431,G__G__GL_127_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TGLUtil::GetDrawQuality) ), 0);
   G__memfunc_setup("SetDrawQuality",1443,G__G__GL_127_0_9, 121, -1, -1, 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - dq", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t))(&TGLUtil::SetDrawQuality) ), 0);
   G__memfunc_setup("ResetDrawQuality",1658,G__G__GL_127_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLUtil::ResetDrawQuality) ), 0);
   G__memfunc_setup("GetDefaultDrawQuality",2140,G__G__GL_127_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TGLUtil::GetDefaultDrawQuality) ), 0);
   G__memfunc_setup("SetDefaultDrawQuality",2152,G__G__GL_127_0_12, 121, -1, -1, 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - dq", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t))(&TGLUtil::SetDefaultDrawQuality) ), 0);
   G__memfunc_setup("LockColor",904,G__G__GL_127_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TGLUtil::LockColor) ), 0);
   G__memfunc_setup("UnlockColor",1131,G__G__GL_127_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TGLUtil::UnlockColor) ), 0);
   G__memfunc_setup("IsColorLocked",1293,G__G__GL_127_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TGLUtil::IsColorLocked) ), 0);
   G__memfunc_setup("Color",511,G__G__GL_127_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "u 'TGLColor' - 11 - color", (char*)NULL, (void*) G__func2void( (void (*)(const TGLColor&))(&TGLUtil::Color) ), 0);
   G__memfunc_setup("ColorAlpha",997,G__G__GL_127_0_17, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'TGLColor' - 11 - color b - 'UChar_t' 0 - alpha", (char*)NULL, (void*) G__func2void( (void (*)(const TGLColor&, UChar_t))(&TGLUtil::ColorAlpha) ), 0);
   G__memfunc_setup("ColorAlpha",997,G__G__GL_127_0_18, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'TGLColor' - 11 - color f - 'Float_t' 0 - alpha", (char*)NULL, (void*) G__func2void( (void (*)(const TGLColor&, Float_t))(&TGLUtil::ColorAlpha) ), 0);
   G__memfunc_setup("ColorAlpha",997,G__G__GL_127_0_19, 121, -1, -1, 0, 2, 3, 1, 0, 
"s - 'Color_t' 0 - color_index f - 'Float_t' 0 '1' alpha", (char*)NULL, (void*) G__func2void( (void (*)(Color_t, Float_t))(&TGLUtil::ColorAlpha) ), 0);
   G__memfunc_setup("ColorTransparency",1785,G__G__GL_127_0_20, 121, -1, -1, 0, 2, 3, 1, 0, 
"s - 'Color_t' 0 - color_index c - 'Char_t' 0 '0' transparency", (char*)NULL, (void*) G__func2void( (void (*)(Color_t, Char_t))(&TGLUtil::ColorTransparency) ), 0);
   G__memfunc_setup("Color3ub",777,G__G__GL_127_0_21, 121, -1, -1, 0, 3, 3, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b", (char*)NULL, (void*) G__func2void( (void (*)(UChar_t, UChar_t, UChar_t))(&TGLUtil::Color3ub) ), 0);
   G__memfunc_setup("Color4ub",778,G__G__GL_127_0_22, 121, -1, -1, 0, 4, 3, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 - a", (char*)NULL, (void*) G__func2void( (void (*)(UChar_t, UChar_t, UChar_t, UChar_t))(&TGLUtil::Color4ub) ), 0);
   G__memfunc_setup("Color3ubv",895,G__G__GL_127_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "B - 'UChar_t' 10 - rgb", (char*)NULL, (void*) G__func2void( (void (*)(const UChar_t*))(&TGLUtil::Color3ubv) ), 0);
   G__memfunc_setup("Color4ubv",896,G__G__GL_127_0_24, 121, -1, -1, 0, 1, 3, 1, 0, "B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const UChar_t*))(&TGLUtil::Color4ubv) ), 0);
   G__memfunc_setup("Color3f",664,G__G__GL_127_0_25, 121, -1, -1, 0, 3, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t))(&TGLUtil::Color3f) ), 0);
   G__memfunc_setup("Color4f",665,G__G__GL_127_0_26, 121, -1, -1, 0, 4, 3, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b f - 'Float_t' 0 - a", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Float_t))(&TGLUtil::Color4f) ), 0);
   G__memfunc_setup("Color3fv",782,G__G__GL_127_0_27, 121, -1, -1, 0, 1, 3, 1, 0, "F - 'Float_t' 10 - rgb", (char*)NULL, (void*) G__func2void( (void (*)(const Float_t*))(&TGLUtil::Color3fv) ), 0);
   G__memfunc_setup("Color4fv",783,G__G__GL_127_0_28, 121, -1, -1, 0, 1, 3, 1, 0, "F - 'Float_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const Float_t*))(&TGLUtil::Color4fv) ), 0);
   G__memfunc_setup("GetPointSizeScale",1709,G__G__GL_127_0_29, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TGLUtil::GetPointSizeScale) ), 0);
   G__memfunc_setup("SetPointSizeScale",1721,G__G__GL_127_0_30, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - scale", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TGLUtil::SetPointSizeScale) ), 0);
   G__memfunc_setup("GetLineWidthScale",1680,G__G__GL_127_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TGLUtil::GetLineWidthScale) ), 0);
   G__memfunc_setup("SetLineWidthScale",1692,G__G__GL_127_0_32, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - scale", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TGLUtil::SetLineWidthScale) ), 0);
   G__memfunc_setup("PointSize",933,G__G__GL_127_0_33, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - point_size", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TGLUtil::PointSize) ), 0);
   G__memfunc_setup("LineWidth",904,G__G__GL_127_0_34, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - line_width", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TGLUtil::LineWidth) ), 0);
   G__memfunc_setup("PointSize",933,G__G__GL_127_0_35, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TGLUtil::PointSize) ), 0);
   G__memfunc_setup("LineWidth",904,G__G__GL_127_0_36, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TGLUtil::LineWidth) ), 0);
   G__memfunc_setup("BeginExtendPickRegion",2104,G__G__GL_127_0_37, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - scale", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TGLUtil::BeginExtendPickRegion) ), 0);
   G__memfunc_setup("EndExtendPickRegion",1898,G__G__GL_127_0_38, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLUtil::EndExtendPickRegion) ), 0);
   G__memfunc_setup("RenderPolyMarkers",1753,G__G__GL_127_0_39, 121, -1, -1, 0, 7, 3, 1, 0, 
"u 'TAttMarker' - 11 - marker c - 'Char_t' 0 - transp "
"F - 'Float_t' 0 - p i - 'Int_t' 0 - n "
"i - 'Int_t' 0 '0' pick_radius g - 'Bool_t' 0 'kFALSE' selection "
"g - 'Bool_t' 0 'kFALSE' sec_selection", (char*)NULL, (void*) G__func2void( (void (*)(const TAttMarker&, Char_t, Float_t*, Int_t, Int_t, Bool_t, Bool_t))(&TGLUtil::RenderPolyMarkers) ), 0);
   G__memfunc_setup("RenderPoints",1245,G__G__GL_127_0_40, 121, -1, -1, 0, 6, 3, 1, 0, 
"u 'TAttMarker' - 11 - marker F - 'Float_t' 0 - p "
"i - 'Int_t' 0 - n i - 'Int_t' 0 '0' pick_radius "
"g - 'Bool_t' 0 'kFALSE' selection g - 'Bool_t' 0 'kFALSE' sec_selection", (char*)NULL, (void*) G__func2void( (void (*)(const TAttMarker&, Float_t*, Int_t, Int_t, Bool_t, Bool_t))(&TGLUtil::RenderPoints) ), 0);
   G__memfunc_setup("RenderCrosses",1346,G__G__GL_127_0_41, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TAttMarker' - 11 - marker F - 'Float_t' 0 - p "
"i - 'Int_t' 0 - n g - 'Bool_t' 0 'kFALSE' sec_selection", (char*)NULL, (void*) G__func2void( (void (*)(const TAttMarker&, Float_t*, Int_t, Bool_t))(&TGLUtil::RenderCrosses) ), 0);
   G__memfunc_setup("RenderPolyLine",1420,G__G__GL_127_0_42, 121, -1, -1, 0, 6, 3, 1, 0, 
"u 'TAttLine' - 11 - aline c - 'Char_t' 0 - transp "
"F - 'Float_t' 0 - p i - 'Int_t' 0 - n "
"i - 'Int_t' 0 '0' pick_radius g - 'Bool_t' 0 'kFALSE' selection", (char*)NULL, (void*) G__func2void( (void (*)(const TAttLine&, Char_t, Float_t*, Int_t, Int_t, Bool_t))(&TGLUtil::RenderPolyLine) ), 0);
   G__memfunc_setup("BeginAttLine",1174,G__G__GL_127_0_43, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TAttLine' - 11 - aline c - 'Char_t' 0 - transp "
"i - 'Int_t' 0 '0' pick_radius g - 'Bool_t' 0 'kFALSE' selection", (char*)NULL, (void*) G__func2void( (void (*)(const TAttLine&, Char_t, Int_t, Bool_t))(&TGLUtil::BeginAttLine) ), 0);
   G__memfunc_setup("EndAttLine",968,G__G__GL_127_0_44, 121, -1, -1, 0, 2, 3, 1, 0, 
"i - 'Int_t' 0 '0' pick_radius g - 'Bool_t' 0 'kFALSE' selection", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Bool_t))(&TGLUtil::EndAttLine) ), 0);
   G__memfunc_setup("SetDrawColors",1324,G__G__GL_127_0_45, 121, -1, -1, 0, 1, 3, 1, 0, "B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const UChar_t*))(&TGLUtil::SetDrawColors) ), 0);
   G__memfunc_setup("DrawSphere",1013,G__G__GL_127_0_46, 121, -1, -1, 0, 3, 3, 1, 0, 
"u 'TGLVertex3' - 11 - position d - 'Double_t' 0 - radius "
"B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, Double_t, const UChar_t*))(&TGLUtil::DrawSphere) ), 0);
   G__memfunc_setup("DrawLine",790,G__G__GL_127_0_47, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TGLLine3' - 11 - line i 'TGLUtil::ELineHeadShape' - 0 - head "
"d - 'Double_t' 0 - size B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const TGLLine3&, TGLUtil::ELineHeadShape, Double_t, const UChar_t*))(&TGLUtil::DrawLine) ), 0);
   G__memfunc_setup("DrawLine",790,G__G__GL_127_0_48, 121, -1, -1, 0, 5, 3, 1, 0, 
"u 'TGLVertex3' - 11 - start u 'TGLVector3' - 11 - vector "
"i 'TGLUtil::ELineHeadShape' - 0 - head d - 'Double_t' 0 - size "
"B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVector3&, TGLUtil::ELineHeadShape, Double_t, const UChar_t*))(&TGLUtil::DrawLine) ), 0);
   G__memfunc_setup("DrawRing",798,G__G__GL_127_0_49, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TGLVertex3' - 11 - center u 'TGLVector3' - 11 - normal "
"d - 'Double_t' 0 - radius B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVector3&, Double_t, const UChar_t*))(&TGLUtil::DrawRing) ), 0);
   G__memfunc_setup("DrawReferenceMarker",1919,G__G__GL_127_0_50, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TGLCamera' - 11 - camera u 'TGLVertex3' - 11 - pos "
"f - 'Float_t' 0 '3' radius B - 'UChar_t' 10 '0' rgba", (char*)NULL, (void*) G__func2void( (void (*)(const TGLCamera&, const TGLVertex3&, Float_t, const UChar_t*))(&TGLUtil::DrawReferenceMarker) ), 0);
   G__memfunc_setup("DrawSimpleAxes",1417,G__G__GL_127_0_51, 121, -1, -1, 0, 3, 3, 1, 0, 
"u 'TGLCamera' - 11 - camera u 'TGLBoundingBox' - 11 - bbox "
"i - 'Int_t' 0 - axesType", (char*)NULL, (void*) G__func2void( (void (*)(const TGLCamera&, const TGLBoundingBox&, Int_t))(&TGLUtil::DrawSimpleAxes) ), 0);
   G__memfunc_setup("DrawNumber",1015,G__G__GL_127_0_52, 121, -1, -1, 0, 3, 3, 1, 0, 
"u 'TString' - 11 - num u 'TGLVertex3' - 11 - pos "
"g - 'Bool_t' 0 'kFALSE' center", (char*)NULL, (void*) G__func2void( (void (*)(const TString&, const TGLVertex3&, Bool_t))(&TGLUtil::DrawNumber) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_127_0_53, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLUtil::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_127_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_127_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLUtil::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_127_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLUtil::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_127_0_57, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_127_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_127_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_127_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_127_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_127_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_127_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_127_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLUtil", 771, G__G__GL_127_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLUtilcLcLTColorLocker(void) {
   /* TGLUtil::TColorLocker */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker));
   G__memfunc_setup("TColorLocker",1203,G__G__GL_128_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_128_0_2, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLUtil::TColorLocker::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_128_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TColorLocker::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_128_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLUtil::TColorLocker::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_128_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLUtil::TColorLocker::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_128_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_128_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_128_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_128_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__GL_128_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TColorLocker::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_128_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::TColorLocker::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_128_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TColorLocker::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_128_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::TColorLocker::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TColorLocker", 1203, G__G__GL_128_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker), -1, 0, 1, 1, 1, 0, "u 'TGLUtil::TColorLocker' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TColorLocker", 1329, G__G__GL_128_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_128_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTColorLocker), -1, 1, 1, 1, 1, 0, "u 'TGLUtil::TColorLocker' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLUtilcLcLTDrawQualityModifier(void) {
   /* TGLUtil::TDrawQualityModifier */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier));
   G__memfunc_setup("TDrawQualityModifier",2042,G__G__GL_129_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_129_0_2, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLUtil::TDrawQualityModifier::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_129_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TDrawQualityModifier::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_129_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLUtil::TDrawQualityModifier::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_129_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLUtil::TDrawQualityModifier::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_129_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_129_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_129_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_129_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__GL_129_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TDrawQualityModifier::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_129_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::TDrawQualityModifier::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_129_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TDrawQualityModifier::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_129_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::TDrawQualityModifier::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDrawQualityModifier", 2042, G__G__GL_129_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier), -1, 0, 1, 1, 1, 0, "u 'TGLUtil::TDrawQualityModifier' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDrawQualityModifier", 2168, G__G__GL_129_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_129_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier), -1, 1, 1, 1, 1, 0, "u 'TGLUtil::TDrawQualityModifier' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLUtilcLcLTDrawQualityScaler(void) {
   /* TGLUtil::TDrawQualityScaler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler));
   G__memfunc_setup("TDrawQualityScaler",1829,G__G__GL_130_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler), -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - fac", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_130_0_2, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLUtil::TDrawQualityScaler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_130_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TDrawQualityScaler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_130_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLUtil::TDrawQualityScaler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_130_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLUtil::TDrawQualityScaler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_130_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_130_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_130_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_130_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__GL_130_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TDrawQualityScaler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_130_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::TDrawQualityScaler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_130_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLUtil::TDrawQualityScaler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_130_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLUtil::TDrawQualityScaler::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDrawQualityScaler", 1829, G__G__GL_130_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler), -1, 0, 1, 1, 1, 0, "u 'TGLUtil::TDrawQualityScaler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDrawQualityScaler", 1955, G__G__GL_130_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_130_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler), -1, 1, 1, 1, 1, 0, "u 'TGLUtil::TDrawQualityScaler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSelectionBuffer(void) {
   /* TGLSelectionBuffer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer));
   G__memfunc_setup("TGLSelectionBuffer",1767,G__G__GL_138_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadColorBuffer",1493,G__G__GL_138_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - width i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadColorBuffer",1493,G__G__GL_138_0_3, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - width i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPixelColor",1313,G__G__GL_138_0_4, 66, -1, G__defined_typename("UChar_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSelectionBuffer",1767,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer), -1, 0, 1, 1, 4, 0, "u 'TGLSelectionBuffer' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSelectionBuffer), -1, 1, 1, 1, 4, 0, "u 'TGLSelectionBuffer' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_138_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSelectionBuffer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_138_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectionBuffer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_138_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSelectionBuffer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_138_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSelectionBuffer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_138_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_138_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_138_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_138_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__GL_138_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectionBuffer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_138_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectionBuffer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_138_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectionBuffer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_138_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectionBuffer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSelectionBuffer", 1893, G__G__GL_138_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPlotCoordinates(void) {
   /* TGLPlotCoordinates */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates));
   G__memfunc_setup("TGLPlotCoordinates",1793,G__G__GL_143_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordType",1221,G__G__GL_143_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EGLCoordType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordType",1209,G__G__GL_143_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_EGLCoordType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXLog",678,G__G__GL_143_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - xLog", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXLog",666,G__G__GL_143_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYLog",679,G__G__GL_143_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - yLog", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYLog",667,G__G__GL_143_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZLog",680,G__G__GL_143_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - zLog", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZLog",668,G__G__GL_143_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetModified",1316,G__G__GL_143_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Modified",801,G__G__GL_143_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRanges",908,G__G__GL_143_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"U 'TH1' - 10 - hist g - 'Bool_t' 0 'kFALSE' errors "
"g - 'Bool_t' 0 'kFALSE' zBins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRanges",908,G__G__GL_143_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TH2Poly' - 0 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRanges",908,G__G__GL_143_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"U 'TAxis' - 10 - xAxis U 'TAxis' - 10 - yAxis "
"U 'TAxis' - 10 - zAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNXBins",850,G__G__GL_143_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNYBins",851,G__G__GL_143_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNZBins",852,G__G__GL_143_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXBins",772,G__G__GL_143_0_18, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR), G__defined_typename("Rgl::BinRange_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYBins",773,G__G__GL_143_0_19, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR), G__defined_typename("Rgl::BinRange_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZBins",774,G__G__GL_143_0_20, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEintcOintgR), G__defined_typename("Rgl::BinRange_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXRange",869,G__G__GL_143_0_21, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXLength",986,G__G__GL_143_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYRange",870,G__G__GL_143_0_23, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYLength",987,G__G__GL_143_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZRange",871,G__G__GL_143_0_25, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZLength",988,G__G__GL_143_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXRangeScaled",1457,G__G__GL_143_0_27, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYRangeScaled",1458,G__G__GL_143_0_28, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZRangeScaled",1459,G__G__GL_143_0_29, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXScale",864,G__G__GL_143_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYScale",865,G__G__GL_143_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZScale",866,G__G__GL_143_0_32, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstXBin",1177,G__G__GL_143_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastXBin",1061,G__G__GL_143_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstYBin",1178,G__G__GL_143_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastYBin",1062,G__G__GL_143_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstZBin",1179,G__G__GL_143_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastZBin",1063,G__G__GL_143_0_38, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFactor",895,G__G__GL_143_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangesPolar",1418,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TH1' - 10 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangesCylindrical",2042,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TH1' - 10 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangesSpherical",1831,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TH1' - 10 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangesCartesian",1830,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 0, 
"U 'TH1' - 10 - hist g - 'Bool_t' 0 'kFALSE' errors "
"g - 'Bool_t' 0 'kFALSE' zBins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPlotCoordinates",1793,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates), -1, 0, 1, 1, 4, 0, "u 'TGLPlotCoordinates' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlotCoordinates), -1, 1, 1, 1, 4, 0, "u 'TGLPlotCoordinates' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_143_0_46, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPlotCoordinates::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_143_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotCoordinates::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_143_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPlotCoordinates::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_143_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPlotCoordinates::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_143_0_50, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_143_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_143_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_143_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_143_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotCoordinates::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_143_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotCoordinates::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_143_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotCoordinates::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_143_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotCoordinates::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPlotCoordinates", 1919, G__G__GL_143_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLQuadric(void) {
   /* TGLQuadric */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLQuadric));
   G__memfunc_setup("TGLQuadric",944,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLQuadric), -1, 0, 1, 1, 2, 0, "u 'TGLQuadric' - 11 - glq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLQuadric), -1, 1, 1, 1, 2, 0, "u 'TGLQuadric' - 11 - glq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLQuadric",944,G__G__GL_144_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLQuadric), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__GL_144_0_4, 85, G__get_linked_tagnum(&G__G__GLLN_GLUquadric), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_144_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLQuadric::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_144_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLQuadric::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_144_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLQuadric::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_144_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLQuadric::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_144_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_144_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_144_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_144_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__GL_144_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLQuadric::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_144_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLQuadric::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_144_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLQuadric::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_144_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLQuadric::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLQuadric", 1070, G__G__GL_144_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRgl(void) {
   /* Rgl */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_Rgl));
   G__memfunc_setup("ObjectIDToColor",1446,G__G__GL_146_0_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - objectID g - 'Bool_t' 0 - highColor", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Bool_t))(&Rgl::ObjectIDToColor) ), 0);
   G__memfunc_setup("ColorToObjectID",1446,G__G__GL_146_0_2, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - color g - 'Bool_t' 0 - highColor", (char*)NULL, (void*) G__func2void( (Int_t (*)(const UChar_t*, Bool_t))(&Rgl::ColorToObjectID) ), 0);
   G__memfunc_setup("DrawQuadOutline",1529,G__G__GL_146_0_3, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TGLVertex3' - 11 - v1 u 'TGLVertex3' - 11 - v2 "
"u 'TGLVertex3' - 11 - v3 u 'TGLVertex3' - 11 - v4", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVertex3&, const TGLVertex3&, const TGLVertex3&))(&Rgl::DrawQuadOutline) ), 0);
   G__memfunc_setup("DrawQuadFilled",1385,G__G__GL_146_0_4, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'TGLVertex3' - 11 - v0 u 'TGLVertex3' - 11 - v1 "
"u 'TGLVertex3' - 11 - v2 u 'TGLVertex3' - 11 - v3 "
"u 'TGLVector3' - 11 - normal", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVertex3&, const TGLVertex3&, const TGLVertex3&, const TGLVector3&))(&Rgl::DrawQuadFilled) ), 0);
   G__memfunc_setup("DrawQuadFilled",1385,G__G__GL_146_0_5, 121, -1, -1, 0, 5, 1, 1, 0, 
"D - 'Double_t' 10 - v0 D - 'Double_t' 10 - v1 "
"D - 'Double_t' 10 - v2 D - 'Double_t' 10 - v3 "
"D - 'Double_t' 10 - normal", (char*)NULL, (void*) G__func2void( (void (*)(const Double_t*, const Double_t*, const Double_t*, const Double_t*, const Double_t*))(&Rgl::DrawQuadFilled) ), 0);
   G__memfunc_setup("DrawSmoothFace",1399,G__G__GL_146_0_6, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'TGLVertex3' - 11 - v1 u 'TGLVertex3' - 11 - v2 "
"u 'TGLVertex3' - 11 - v3 u 'TGLVector3' - 11 - norm1 "
"u 'TGLVector3' - 11 - norm2 u 'TGLVector3' - 11 - norm3", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVertex3&, const TGLVertex3&, const TGLVector3&, const TGLVector3&, const TGLVector3&))(&Rgl::DrawSmoothFace) ), 0);
   G__memfunc_setup("DrawBoxFront",1216,G__G__GL_146_0_7, 121, -1, -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - xMin d - 'Double_t' 0 - xMax "
"d - 'Double_t' 0 - yMin d - 'Double_t' 0 - yMax "
"d - 'Double_t' 0 - zMin d - 'Double_t' 0 - zMax "
"i - 'Int_t' 0 - fp", (char*)NULL, (void*) G__func2void( (void (*)(Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Int_t))(&Rgl::DrawBoxFront) ), 0);
   G__memfunc_setup("DrawBoxFrontTextured",2069,G__G__GL_146_0_8, 121, -1, -1, 0, 9, 1, 1, 0, 
"d - 'Double_t' 0 - xMin d - 'Double_t' 0 - xMax "
"d - 'Double_t' 0 - yMin d - 'Double_t' 0 - yMax "
"d - 'Double_t' 0 - zMin d - 'Double_t' 0 - zMax "
"d - 'Double_t' 0 - tMin d - 'Double_t' 0 - tMax "
"i - 'Int_t' 0 - front", (char*)NULL, (void*) G__func2void( (void (*)(Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Int_t))(&Rgl::DrawBoxFrontTextured) ), 0);
   G__memfunc_setup("DrawCylinder",1224,G__G__GL_146_0_9, 121, -1, -1, 0, 7, 1, 1, 0, 
"U 'TGLQuadric' - 0 - quadric d - 'Double_t' 0 - xMin "
"d - 'Double_t' 0 - xMax d - 'Double_t' 0 - yMin "
"d - 'Double_t' 0 - yMax d - 'Double_t' 0 - zMin "
"d - 'Double_t' 0 - zMax", (char*)NULL, (void*) G__func2void( (void (*)(TGLQuadric*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&Rgl::DrawCylinder) ), 0);
   G__memfunc_setup("DrawSphere",1013,G__G__GL_146_0_10, 121, -1, -1, 0, 7, 1, 1, 0, 
"U 'TGLQuadric' - 0 - quadric d - 'Double_t' 0 - xMin "
"d - 'Double_t' 0 - xMax d - 'Double_t' 0 - yMin "
"d - 'Double_t' 0 - yMax d - 'Double_t' 0 - zMin "
"d - 'Double_t' 0 - zMax", (char*)NULL, (void*) G__func2void( (void (*)(TGLQuadric*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&Rgl::DrawSphere) ), 0);
   G__memfunc_setup("DrawError",920,G__G__GL_146_0_11, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xMin d - 'Double_t' 0 - xMax "
"d - 'Double_t' 0 - yMin d - 'Double_t' 0 - yMax "
"d - 'Double_t' 0 - zMin d - 'Double_t' 0 - zMax", (char*)NULL, (void*) G__func2void( (void (*)(Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&Rgl::DrawError) ), 0);
   G__memfunc_setup("DrawAxes",799,G__G__GL_146_0_12, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - frontPoint I - 'Int_t' 10 - viewport "
"U 'TGLVertex3' - 10 - box2D U 'TGLPlotCoordinates' - 10 - plotCoord "
"U 'TAxis' - 0 - xAxis U 'TAxis' - 0 - yAxis "
"U 'TAxis' - 0 - zAxis", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, const Int_t*, const TGLVertex3*, const TGLPlotCoordinates*, TAxis*, TAxis*, TAxis*))(&Rgl::DrawAxes) ), 0);
   G__memfunc_setup("SetZLevels",1009,G__G__GL_146_0_13, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TAxis' - 0 - zAxis d - 'Double_t' 0 - zMin "
"d - 'Double_t' 0 - zMax d - 'Double_t' 0 - zScale "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - zLevels", (char*)NULL, (void*) G__func2void( (void (*)(TAxis*, Double_t, Double_t, Double_t, vector<Double_t>&))(&Rgl::SetZLevels) ), 0);
   G__memfunc_setup("DrawFaceTextured",1618,G__G__GL_146_0_14, 121, -1, -1, 0, 9, 1, 1, 0, 
"u 'TGLVertex3' - 11 - v1 u 'TGLVertex3' - 11 - v2 "
"u 'TGLVertex3' - 11 - v3 d - 'Double_t' 0 - t1 "
"d - 'Double_t' 0 - t2 d - 'Double_t' 0 - t3 "
"u 'TGLVector3' - 11 - norm1 u 'TGLVector3' - 11 - norm2 "
"u 'TGLVector3' - 11 - norm3", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVertex3&, const TGLVertex3&, Double_t, Double_t, Double_t, const TGLVector3&, const TGLVector3&, const TGLVector3&))(&Rgl::DrawFaceTextured) ), 0);
   G__memfunc_setup("DrawFaceTextured",1618,G__G__GL_146_0_15, 121, -1, -1, 0, 8, 1, 1, 0, 
"u 'TGLVertex3' - 11 - v1 u 'TGLVertex3' - 11 - v2 "
"u 'TGLVertex3' - 11 - v3 d - 'Double_t' 0 - t1 "
"d - 'Double_t' 0 - t2 d - 'Double_t' 0 - t3 "
"d - 'Double_t' 0 - z u 'TGLVector3' - 11 - planeNormal", (char*)NULL, (void*) G__func2void( (void (*)(const TGLVertex3&, const TGLVertex3&, const TGLVertex3&, Double_t, Double_t, Double_t, Double_t, const TGLVector3&))(&Rgl::DrawFaceTextured) ), 0);
   G__memfunc_setup("GetColor",799,G__G__GL_146_0_16, 121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 - v f - 'Float_t' 0 - vmin "
"f - 'Float_t' 0 - vmax i - 'Int_t' 0 - type "
"F - 'Float_t' 0 - rgba", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Float_t, Float_t, Int_t, Float_t*))(&Rgl::GetColor) ), 0);
   G__memfunc_setup("DrawPalette",1117,G__G__GL_146_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLPlotCamera' - 10 - camera u 'TGLLevelPalette' - 11 - palette", (char*)NULL, (void*) G__func2void( (void (*)(const TGLPlotCamera*, const TGLLevelPalette&))(&Rgl::DrawPalette) ), 0);
   G__memfunc_setup("DrawPaletteAxis",1522,G__G__GL_146_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGLPlotCamera' - 10 - camera u 'pair<double,double>' 'Rgl::Range_t' 11 - minMax "
"g - 'Bool_t' 0 - logZ", (char*)NULL, (void*) G__func2void( (void (*)(const TGLPlotCamera*, const Rgl::Range_t&, Bool_t))(&Rgl::DrawPaletteAxis) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - vs u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - ns "
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Float_t>&, const vector<Float_t>&, const vector<UInt_t>&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_20, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - vs u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - ns "
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Double_t>&, const vector<Double_t>&, const vector<UInt_t>&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - vs u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - fTS", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Float_t>&, const vector<UInt_t>&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - vs u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - fTS", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Double_t>&, const vector<UInt_t>&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_23, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - vs u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - ns "
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts u 'TGLBoxCut' - 11 - box", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Float_t>&, const vector<Float_t>&, const vector<UInt_t>&, const TGLBoxCut&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - vs u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - ns "
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts u 'TGLBoxCut' - 11 - box", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Double_t>&, const vector<Double_t>&, const vector<UInt_t>&, const TGLBoxCut&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - vs u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts "
"u 'TGLBoxCut' - 11 - box", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Float_t>&, const vector<UInt_t>&, const TGLBoxCut&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMesh",795,G__G__GL_146_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - vs u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts "
"u 'TGLBoxCut' - 11 - box", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Double_t>&, const vector<UInt_t>&, const TGLBoxCut&))(&Rgl::DrawMesh) ), 0);
   G__memfunc_setup("DrawMapleMesh",1290,G__G__GL_146_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - vs u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - ns "
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Double_t>&, const vector<Double_t>&, const vector<UInt_t>&))(&Rgl::DrawMapleMesh) ), 0);
   G__memfunc_setup("DrawMapleMesh",1290,G__G__GL_146_0_28, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - vs u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - ns "
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 11 - ts u 'TGLBoxCut' - 11 - box", (char*)NULL, (void*) G__func2void( (void (*)(const vector<Double_t>&, const vector<Double_t>&, const vector<UInt_t>&, const TGLBoxCut&))(&Rgl::DrawMapleMesh) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPhysicalShape(void) {
   /* TGLPhysicalShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape));
   G__memfunc_setup("TGLPhysicalShape",1557,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 1, 1, 4, 0, "u 'TGLPhysicalShape' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 1, 1, 1, 4, 0, "u 'TGLPhysicalShape' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("UpdateBoundingBox",1730,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitColor",915,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPhysicalShape",1557,G__G__GL_162_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 5, 1, 1, 0, 
"h - 'UInt_t' 0 - ID u 'TGLLogicalShape' - 11 - logicalShape "
"u 'TGLMatrix' - 11 - transform g - 'Bool_t' 0 - invertedWind "
"F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPhysicalShape",1557,G__G__GL_162_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 5, 1, 1, 0, 
"h - 'UInt_t' 0 - ID u 'TGLLogicalShape' - 11 - logicalShape "
"D - - 10 - transform g - 'Bool_t' 0 - invertedWind "
"F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddReference",1176,G__G__GL_162_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPShapeRef' - 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveReference",1533,G__G__GL_162_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPShapeRef' - 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ID",141,G__G__GL_162_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoundingBox",1119,G__G__GL_162_0_10, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateShapeLOD",1630,G__G__GL_162_0_11, 121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx f - 'Float_t' 1 - pixSize "
"s - 'Short_t' 1 - shapeLOD", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QuantizeShapeLOD",1569,G__G__GL_162_0_12, 121, -1, -1, 0, 3, 1, 1, 8, 
"s - 'Short_t' 0 - shapeLOD s - 'Short_t' 0 - combiLOD "
"s - 'Short_t' 1 - quantLOD", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupGLColors",1302,G__G__GL_162_0_13, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx F - 'Float_t' 10 '0' color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,G__G__GL_162_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogical",987,G__G__GL_162_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextPhysical",1532,G__G__GL_162_0_16, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetManip",789,G__G__GL_162_0_17, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShapecLcLEManip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetManip",801,G__G__GL_162_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLPhysicalShape::EManip' - 0 - manip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Modified",801,G__G__GL_162_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsModified",989,G__G__GL_162_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSelected",997,G__G__GL_162_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelected",1097,G__G__GL_162_0_22, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Select",608,G__G__GL_162_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Color",511,G__G__GL_162_0_24, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTransparent",1358,G__G__GL_162_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInvisible",1121,G__G__GL_162_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColor",811,G__G__GL_162_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColorOnFamily",1610,G__G__GL_162_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDiffuseColor",1521,G__G__GL_162_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDiffuseColor",1521,G__G__GL_162_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "B - 'UChar_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDiffuseColor",1521,G__G__GL_162_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - ci b - 'UChar_t' 0 - transparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__GL_162_0_32, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTranslation",1455,G__G__GL_162_0_33, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransform",1256,G__G__GL_162_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLMatrix' - 11 - transform", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransform",1256,G__G__GL_162_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - vals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__GL_162_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVertex3' - 11 - translation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Translate",942,G__G__GL_162_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 11 - vect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__GL_162_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLVector3' - 11 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rotate",623,G__G__GL_162_0_39, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLVertex3' - 11 - pivot u 'TGLVector3' - 11 - axis "
"d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvokeContextMenu",1766,G__G__GL_162_0_40, 121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TContextMenu' - 1 - menu h - 'UInt_t' 0 - x "
"h - 'UInt_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_162_0_41, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPhysicalShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_162_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPhysicalShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_162_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPhysicalShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_162_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPhysicalShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_162_0_45, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_162_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_162_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_162_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_162_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPhysicalShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_162_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPhysicalShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_162_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPhysicalShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_162_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPhysicalShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPhysicalShape", 1683, G__G__GL_162_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLRnrCtx(void) {
   /* TGLRnrCtx */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx));
   G__memfunc_setup("StyleName",914,G__G__GL_163_0_1, 67, -1, -1, 0, 1, 3, 1, 1, "s - 'Short_t' 0 - style", (char*)NULL, (void*) G__func2void( (const char* (*)(Short_t))(&TGLRnrCtx::StyleName) ), 0);
   G__memfunc_setup("TGLRnrCtx",840,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx), -1, 0, 1, 1, 4, 0, "u 'TGLRnrCtx' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx), -1, 1, 1, 1, 4, 0, "u 'TGLRnrCtx' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLRnrCtx",840,G__G__GL_163_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx), -1, 0, 1, 1, 1, 0, "U 'TGLViewerBase' - 0 - viewer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewer",914,G__G__GL_163_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefViewer",911,G__G__GL_163_0_6, 117, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCamera",873,G__G__GL_163_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefCamera",870,G__G__GL_163_0_8, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSceneInfo",1178,G__G__GL_163_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefSceneInfo",1175,G__G__GL_163_0_10, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScene",782,G__G__GL_163_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefScene",779,G__G__GL_163_0_12, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefCamera",870,G__G__GL_163_0_13, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCamera",873,G__G__GL_163_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCamera",885,G__G__GL_163_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLCamera' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneInfo",1190,G__G__GL_163_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLSceneInfo' - 0 - si", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewerLOD",849,G__G__GL_163_0_17, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewerLOD",1149,G__G__GL_163_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - LOD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneLOD",717,G__G__GL_163_0_19, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneLOD",1017,G__G__GL_163_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - LOD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CombiLOD",713,G__G__GL_163_0_21, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCombiLOD",1013,G__G__GL_163_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - LOD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShapeLOD",720,G__G__GL_163_0_23, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShapeLOD",1020,G__G__GL_163_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - LOD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShapePixSize",1213,G__G__GL_163_0_25, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShapePixSize",1513,G__G__GL_163_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - ps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewerStyle",1155,G__G__GL_163_0_27, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewerStyle",1455,G__G__GL_163_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - sty", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneStyle",1023,G__G__GL_163_0_29, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneStyle",1323,G__G__GL_163_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - sty", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewerWFLineW",1262,G__G__GL_163_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewerWFLineW",1562,G__G__GL_163_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneWFLineW",1130,G__G__GL_163_0_33, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneWFLineW",1430,G__G__GL_163_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewerOLLineW",1260,G__G__GL_163_0_35, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewerOLLineW",1560,G__G__GL_163_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneOLLineW",1128,G__G__GL_163_0_37, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneOLLineW",1428,G__G__GL_163_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewerClip",1018,G__G__GL_163_0_39, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewerClip",1318,G__G__GL_163_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneClip",886,G__G__GL_163_0_41, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneClip",1186,G__G__GL_163_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clip",392,G__G__GL_163_0_43, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClip",692,G__G__GL_163_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasClip",676,G__G__GL_163_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPass",805,G__G__GL_163_0_46, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawPass",1105,G__G__GL_163_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - dpass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDrawPassFilled",1585,G__G__GL_163_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDrawPassOutlineLine",2121,G__G__GL_163_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderTimeOut",1319,G__G__GL_163_0_50, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRenderTimeOut",1619,G__G__GL_163_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartStopwatch",1483,G__G__GL_163_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopStopwatch",1379,G__G__GL_163_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStopwatchRunning",1882,G__G__GL_163_0_54, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasStopwatchTimedOut",2052,G__G__GL_163_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Highlight",920,G__G__GL_163_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHighlight",1220,G__G__GL_163_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - hil", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighlightOutline",1656,G__G__GL_163_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHighlightOutline",1956,G__G__GL_163_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Selection",934,G__G__GL_163_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelection",1234,G__G__GL_163_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SecSelection",1217,G__G__GL_163_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSecSelection",1517,G__G__GL_163_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - secSel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPickRectangle",1596,G__G__GL_163_0_64, 85, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPickRadius",1295,G__G__GL_163_0_65, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectBuffer",1498,G__G__GL_163_0_66, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginSelection",1419,G__G__GL_163_0_67, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 '3' r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndSelection",1213,G__G__GL_163_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - glResult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PushColorSet",1227,G__G__GL_163_0_69, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorSet",811,G__G__GL_163_0_70, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopColorSet",1114,G__G__GL_163_0_71, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeBaseColorSet",1772,G__G__GL_163_0_72, 85, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 0, 1, 1, 1, 0, "U 'TGLColorSet' - 0 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseColorSet",1478,G__G__GL_163_0_73, 85, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorOrForeground",1755,G__G__GL_163_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRenderScale",1384,G__G__GL_163_0_75, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRenderScale",1396,G__G__GL_163_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventKeySym",1412,G__G__GL_163_0_77, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEventKeySym",1424,G__G__GL_163_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDLCaptureOpen",1458,G__G__GL_163_0_79, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenDLCapture",1270,G__G__GL_163_0_80, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseDLCapture",1370,G__G__GL_163_0_81, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGLCtxIdentity",1580,G__G__GL_163_0_82, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGLCtxIdentity",1592,G__G__GL_163_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLContextIdentity' - 0 - cid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterFont",1244,G__G__GL_163_0_84, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 0 - file "
"i - 'Int_t' 0 - mode u 'TGLFont' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterFont",1244,G__G__GL_163_0_85, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - size C - - 10 - name "
"i - 'Int_t' 0 - mode u 'TGLFont' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterFontNoScale",1921,G__G__GL_163_0_86, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 0 - file "
"i - 'Int_t' 0 - mode u 'TGLFont' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterFontNoScale",1921,G__G__GL_163_0_87, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - size C - - 10 - name "
"i - 'Int_t' 0 - mode u 'TGLFont' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseFont",1112,G__G__GL_163_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLFont' - 1 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGluQuadric",1297,G__G__GL_163_0_89, 85, G__get_linked_tagnum(&G__G__GLLN_GLUquadric), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGrabImage",1163,G__G__GL_163_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - gi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGrabImage",1151,G__G__GL_163_0_91, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectionMatrixPushIdentity",2940,G__G__GL_163_0_92, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectionMatrixPop",1985,G__G__GL_163_0_93, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_163_0_94, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLRnrCtx::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_163_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRnrCtx::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_163_0_96, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLRnrCtx::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_163_0_97, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLRnrCtx::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_163_0_98, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_163_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_163_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_163_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_163_0_102, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRnrCtx::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_163_0_103, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLRnrCtx::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_163_0_104, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRnrCtx::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_163_0_105, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLRnrCtx::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLRnrCtx", 966, G__G__GL_163_0_106, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSelectRecord(void) {
   /* TGLSelectRecord */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord));
   G__memfunc_setup("TGLSelectRecord",1446,G__G__GL_164_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSelectRecord",1446,G__G__GL_164_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord), -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSelectRecord",1446,G__G__GL_164_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord), -1, 0, 1, 1, 1, 0, "u 'TGLSelectRecord' - 11 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_164_0_4, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord), -1, 1, 1, 1, 1, 0, "u 'TGLSelectRecord' - 11 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTransparent",1458,G__G__GL_164_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSceneInfo",1178,G__G__GL_164_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhysShape",1205,G__G__GL_164_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__GL_164_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpecific",1094,G__G__GL_164_0_11, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMultiple",1132,G__G__GL_164_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHighlight",1208,G__G__GL_164_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecSelResult",1502,G__G__GL_164_0_14, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransparent",1470,G__G__GL_164_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneInfo",1190,G__G__GL_164_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLSceneInfo' - 0 - si", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhysShape",1217,G__G__GL_164_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - pshp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetObject",899,G__G__GL_164_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSpecific",1106,G__G__GL_164_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - spec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMultiple",1144,G__G__GL_164_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - multi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHighlight",1220,G__G__GL_164_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - hlt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSecSelResult",1514,G__G__GL_164_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLSelectRecord::ESecSelResult' - 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__GL_164_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AreSameSelectionWise",2012,G__G__GL_164_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 1, 0, 
"u 'TGLSelectRecord' - 11 - r1 u 'TGLSelectRecord' - 11 - r2", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGLSelectRecord&, const TGLSelectRecord&))(&TGLSelectRecord::AreSameSelectionWise) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_164_0_25, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSelectRecord::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_164_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectRecord::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_164_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSelectRecord::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_164_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSelectRecord::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_164_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_164_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectRecord::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_164_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectRecord::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_164_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectRecord::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_164_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectRecord::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSelectRecord", 1572, G__G__GL_164_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLViewer(void) {
   /* TGLViewer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewer));
   G__memfunc_setup("TGLViewer",857,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewer), -1, 0, 1, 1, 4, 0, "u 'TGLViewer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLViewer), -1, 1, 1, 1, 4, 0, "u 'TGLViewer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitSecondaryObjects",2054,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupClipObject",1520,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreDraw",693,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PostDraw",820,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FadeView",779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCurrent",1121,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwapBuffers",1128,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewport",1164,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
"i - 'Int_t' 0 - width i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewport",1164,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRect' - 11 - vp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupCameras",1229,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - reset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLViewer",857,G__G__GL_165_0_14, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewer), -1, 0, 5, 1, 1, 0, 
"U 'TVirtualPad' - 0 - pad i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y i - 'Int_t' 0 - width "
"i - 'Int_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLViewer",857,G__G__GL_165_0_15, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewer), -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanLoopOnPrimitives",1941,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PadPaint",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreferLocalFrame",1594,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginScene",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildingScene",1308,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EndScene",773,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddObject",864,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer3D' - 11 - - G - 'Bool_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddObject",864,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - - u 'TBuffer3D' - 11 - - "
"G - 'Bool_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenComposite",1349,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer3D' - 11 - - G - 'Bool_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseComposite",1449,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddCompositeOp",1403,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintObjects",1239,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCameras",1215,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCamerasAfterNextUpdate",2739,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGLWidget",1047,G__G__GL_165_0_32, 85, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateGLWidget",1355,G__G__GL_165_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyGLWidget",1505,G__G__GL_165_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDev",575,G__G__GL_165_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmartRefresh",1526,G__G__GL_165_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSmartRefresh",1538,G__G__GL_165_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - smart_ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefDarkColorSet",1482,G__G__GL_165_0_38, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefLightColorSet",1600,G__G__GL_165_0_39, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorSet",811,G__G__GL_165_0_40, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseDarkColorSet",1498,G__G__GL_165_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseLightColorSet",1616,G__G__GL_165_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwitchColorSet",1437,G__G__GL_165_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseDefaultColorSet",1821,G__G__GL_165_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsUsingDefaultColorSet",2226,G__G__GL_165_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsColorSetDark",1385,G__G__GL_165_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClearColor",1298,G__G__GL_165_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultColorSet",1808,G__G__GL_165_0_48, 117, G__get_linked_tagnum(&G__G__GLLN_TGLColorSet), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLColorSet& (*)())(&TGLViewer::GetDefaultColorSet) ), 0);
   G__memfunc_setup("UseDefaultColorSetForNewViewers",3155,G__G__GL_165_0_49, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TGLViewer::UseDefaultColorSetForNewViewers) ), 0);
   G__memfunc_setup("IsUsingDefaultColorSetForNewViewers",3560,G__G__GL_165_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TGLViewer::IsUsingDefaultColorSetForNewViewers) ), 0);
   G__memfunc_setup("RefViewport",1149,G__G__GL_165_0_51, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRect), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportDiagonal",1663,G__G__GL_165_0_52, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointScale",1298,G__G__GL_165_0_53, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineScale",1168,G__G__GL_165_0_54, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPointScale",1310,G__G__GL_165_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineScale",1180,G__G__GL_165_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmoothPoints",1559,G__G__GL_165_0_57, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmoothLines",1429,G__G__GL_165_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSmoothPoints",1571,G__G__GL_165_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSmoothLines",1441,G__G__GL_165_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLightSet",1092,G__G__GL_165_0_61, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLightSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipSet",980,G__G__GL_165_0_62, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClipSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipAutoUpdate",1700,G__G__GL_165_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipAutoUpdate",1712,G__G__GL_165_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CurrentCamera",1324,G__G__GL_165_0_65, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefCamera",870,G__G__GL_165_0_66, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 1, 1, 1, 1, 0, "i 'TGLViewer::ECameraType' - 0 - camera", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentCamera",1624,G__G__GL_165_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLViewer::ECameraType' - 0 - camera", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOrthoCamera",1409,G__G__GL_165_0_68, 121, -1, -1, 0, 6, 1, 1, 0, 
"i 'TGLViewer::ECameraType' - 0 - camera d - 'Double_t' 0 - zoom "
"d - 'Double_t' 0 - dolly D - 'Double_t' 0 - center "
"d - 'Double_t' 0 - hRotate d - 'Double_t' 0 - vRotate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPerspectiveCamera",2047,G__G__GL_165_0_69, 121, -1, -1, 0, 6, 1, 1, 0, 
"i 'TGLViewer::ECameraType' - 0 - camera d - 'Double_t' 0 - fov "
"d - 'Double_t' 0 - dolly D - 'Double_t' 0 - center "
"d - 'Double_t' 0 - hRotate d - 'Double_t' 0 - vRotate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGuideState",1295,G__G__GL_165_0_70, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 1 - axesType g - 'Bool_t' 1 - axesDepthTest "
"g - 'Bool_t' 1 - referenceOn D - 'Double_t' 0 - referencePos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGuideState",1307,G__G__GL_165_0_71, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - axesType g - 'Bool_t' 0 - axesDepthTest "
"g - 'Bool_t' 0 - referenceOn D - 'Double_t' 10 - referencePos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawCameraCenter",1892,G__G__GL_165_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawCameraCenter",1880,G__G__GL_165_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PickCameraCenter",1585,G__G__GL_165_0_74, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PickAnnotate",1217,G__G__GL_165_0_75, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCameraOverlay",1611,G__G__GL_165_0_76, 85, G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCameraOverlay",1623,G__G__GL_165_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLCameraOverlay' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoRotator",1444,G__G__GL_165_0_78, 85, G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoRotator",1456,G__G__GL_165_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLAutoRotator' - 0 - ar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStereo",914,G__G__GL_165_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStereoZeroParallax",2151,G__G__GL_165_0_81, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStereoEyeOffsetFac",2086,G__G__GL_165_0_82, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStereoFrustumAsymFac",2348,G__G__GL_165_0_83, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStereo",926,G__G__GL_165_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStereoZeroParallax",2163,G__G__GL_165_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStereoEyeOffsetFac",2098,G__G__GL_165_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStereoFrustumAsymFac",2360,G__G__GL_165_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPushAction",1310,G__G__GL_165_0_88, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEPushAction), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDragAction",1276,G__G__GL_165_0_89, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewercLcLEDragAction), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelected",1097,G__G__GL_165_0_90, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxSceneDrawTimeHQ",2026,G__G__GL_165_0_91, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxSceneDrawTimeLQ",2030,G__G__GL_165_0_92, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxSceneDrawTimeHQ",2038,G__G__GL_165_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxSceneDrawTimeLQ",2042,G__G__GL_165_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RequestDraw",1143,G__G__GL_165_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 'TGLRnrCtx::kLODMed' LOD", "Cross thread draw request", (void*) NULL, 0);
   G__memfunc_setup("PreRender",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostRender",1030,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoDraw",577,G__G__GL_165_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' swap_buffers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDrawMono",986,G__G__GL_165_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - swap_buffers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDrawStereo",1203,G__G__GL_165_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - swap_buffers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawGuides",1007,G__G__GL_165_0_101, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawDebugInfo",1281,G__G__GL_165_0_102, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RequestSelect",1353,G__G__GL_165_0_103, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "Cross thread select request", (void*) NULL, 0);
   G__memfunc_setup("DoSelect",787,G__G__GL_165_0_104, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "First level selecton (shapes/objects).", (void*) NULL, 0);
   G__memfunc_setup("RequestSecondarySelect",2289,G__G__GL_165_0_105, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "Cross thread secondary select request", (void*) NULL, 0);
   G__memfunc_setup("DoSecondarySelect",1723,G__G__GL_165_0_106, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "Second level selecton (inner structure).", (void*) NULL, 0);
   G__memfunc_setup("ApplySelection",1452,G__G__GL_165_0_107, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RequestOverlaySelect",2091,G__G__GL_165_0_108, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "Cross thread select request", (void*) NULL, 0);
   G__memfunc_setup("DoOverlaySelect",1525,G__G__GL_165_0_109, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", "Window coords origin top left", (void*) NULL, 0);
   G__memfunc_setup("SavePicture",1131,G__G__GL_165_0_110, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePicture",1131,G__G__GL_165_0_111, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - fileName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePictureUsingBB",1781,G__G__GL_165_0_112, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - fileName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePictureUsingFBO",1864,G__G__GL_165_0_113, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TString' - 11 - fileName i - 'Int_t' 0 - w "
"i - 'Int_t' 0 - h f - 'Float_t' 0 '0' pixel_object_scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePictureWidth",1643,G__G__GL_165_0_114, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 11 - fileName i - 'Int_t' 0 - width "
"g - 'Bool_t' 0 'kTRUE' pixel_object_scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePictureHeight",1732,G__G__GL_165_0_115, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 11 - fileName i - 'Int_t' 0 - height "
"g - 'Bool_t' 0 'kTRUE' pixel_object_scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePictureScale",1619,G__G__GL_165_0_116, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 11 - fileName f - 'Float_t' 0 - scale "
"g - 'Bool_t' 0 'kTRUE' pixel_object_scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPictureFileName",1789,G__G__GL_165_0_117, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPictureFileName",1801,G__G__GL_165_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFader",770,G__G__GL_165_0_119, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFader",782,G__G__GL_165_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AutoFade",777,G__G__GL_165_0_121, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - fade f - 'Float_t' 0 '1' time "
"i - 'Int_t' 0 '10' steps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateScene",1105,G__G__GL_165_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' redraw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIgnoreSizesOnUpdate",2226,G__G__GL_165_0_123, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIgnoreSizesOnUpdate",2238,G__G__GL_165_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetCurrentCamera",1839,G__G__GL_165_0_125, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResetCamerasOnUpdate",2303,G__G__GL_165_0_126, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResetCamerasOnUpdate",2315,G__G__GL_165_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PostSceneBuildSetup",1941,G__G__GL_165_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - resetCameras", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Activated",917,G__G__GL_165_0_129, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MouseIdle",903,G__G__GL_165_0_130, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGLPhysicalShape' - 0 - - h - 'UInt_t' 0 - - "
"h - 'UInt_t' 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MouseOver",933,G__G__GL_165_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MouseOver",933,G__G__GL_165_0_132, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLPhysicalShape' - 0 - - h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("MouseOver",933,G__G__GL_165_0_133, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReMouseOver",1116,G__G__GL_165_0_134, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("UnMouseOver",1128,G__G__GL_165_0_135, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__GL_165_0_136, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__GL_165_0_137, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - button "
"h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("ReClicked",870,G__G__GL_165_0_138, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - button "
"h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("UnClicked",882,G__G__GL_165_0_139, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - button "
"h - 'UInt_t' 0 - state", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("DoubleClicked",1290,G__G__GL_165_0_140, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetEventHandler",1504,G__G__GL_165_0_141, 85, G__get_linked_tagnum(&G__G__GLLN_TGEventHandler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEventHandler",1516,G__G__GL_165_0_142, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGEventHandler' - 0 - handler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGedEditor",1175,G__G__GL_165_0_143, 85, G__get_linked_tagnum(&G__G__GLLN_TGedEditor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGedEditor",1187,G__G__GL_165_0_144, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedEditor' - 0 - ed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectionChanged",1616,G__G__GL_165_0_145, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OverlayDragFinished",1930,G__G__GL_165_0_146, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RefreshPadEditor",1611,G__G__GL_165_0_147, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveOverlayElement",2074,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLOverlayElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelRec",862,G__G__GL_165_0_149, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecord), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOvlSelRec",1167,G__G__GL_165_0_150, 117, G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentOvlElm",1618,G__G__GL_165_0_151, 85, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearCurrentOvlElm",1817,G__G__GL_165_0_152, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_165_0_153, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLViewer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_165_0_154, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_165_0_155, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLViewer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_165_0_156, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLViewer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_165_0_160, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_165_0_161, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_165_0_162, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLViewer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_165_0_163, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_165_0_164, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLViewer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLViewer", 983, G__G__GL_165_0_165, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSceneBase(void) {
   /* TGLSceneBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase), -1, 1, 1, 1, 4, 0, "u 'TGLSceneBase' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("AddViewer",891,G__G__GL_166_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLViewerBase' - 0 - viewer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveViewer",1248,G__G__GL_166_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLViewerBase' - 0 - viewer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TagViewersChanged",1707,G__G__GL_166_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LockIdStr",879,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,G__G__GL_166_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,G__G__GL_166_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,G__G__GL_166_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__GL_166_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNameTitle",1199,G__G__GL_166_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateSceneInfo",1486,G__G__GL_166_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 1, 1, 1, 0, "U 'TGLViewerBase' - 0 - view", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebuildSceneInfo",1601,G__G__GL_166_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - ctx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateSceneInfo",1501,G__G__GL_166_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - ctx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LodifySceneInfo",1505,G__G__GL_166_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - ctx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreDraw",693,G__G__GL_166_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreRender",903,G__G__GL_166_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,G__G__GL_166_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderOpaque",1227,G__G__GL_166_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderTransp",1240,G__G__GL_166_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderSelOpaque",1519,G__G__GL_166_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderSelTransp",1532,G__G__GL_166_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostRender",1030,G__G__GL_166_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostDraw",820,G__G__GL_166_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLogical",1084,G__G__GL_166_0_26, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 1, 1, 1, 8, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResolveSelectRecord",1951,G__G__GL_166_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLSelectRecord' - 1 - rec i - 'Int_t' 0 - curIdx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTimeStamp",1204,G__G__GL_166_0_28, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncTimeStamp",1198,G__G__GL_166_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinorStamp",1322,G__G__GL_166_0_30, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncMinorStamp",1316,G__G__GL_166_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LOD",223,G__G__GL_166_0_32, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLOD",523,G__G__GL_166_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - lod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Style",529,G__G__GL_166_0_34, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStyle",829,G__G__GL_166_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clip",392,G__G__GL_166_0_36, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClip",692,G__G__GL_166_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectable",1300,G__G__GL_166_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelectable",1312,G__G__GL_166_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoDestruct",1543,G__G__GL_166_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoDestruct",1555,G__G__GL_166_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcBoundingBox",1490,G__G__GL_166_0_42, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InvalidateBoundingBox",2144,G__G__GL_166_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoundingBox",1119,G__G__GL_166_0_44, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_166_0_45, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSceneBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_166_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSceneBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_166_0_47, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSceneBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_166_0_48, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSceneBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_166_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_166_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSceneBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_166_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSceneBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_166_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSceneBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_166_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSceneBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSceneBase", 1230, G__G__GL_166_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLScene(void) {
   /* TGLScene */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScene));
   G__memfunc_setup("TGLScene",725,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScene), -1, 0, 1, 1, 4, 0, "u 'TGLScene' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLScene), -1, 1, 1, 1, 4, 0, "u 'TGLScene' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ComparePhysicalVolumes",2287,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 4, 0, 
"U 'TGLPhysicalShape' - 10 - shape1 U 'TGLPhysicalShape' - 10 - shape2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComparePhysicalDiagonals",2454,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 4, 0, 
"U 'TGLPhysicalShape' - 10 - shape1 U 'TGLPhysicalShape' - 10 - shape2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyPhysicalInternal",2404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'map<unsigned int,TGLPhysicalShape*,less<unsigned int>,allocator<pair<const unsigned int,TGLPhysicalShape*> > >::iterator' 'TGLScene::PhysicalShapeMapIt_t' 0 - pit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReleaseGLCtxIdentity",1997,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLScene",725,G__G__GL_167_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScene), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcBoundingBox",1490,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateSceneInfo",1486,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo), -1, 0, 1, 1, 1, 0, "U 'TGLViewerBase' - 0 - view", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebuildSceneInfo",1601,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateSceneInfo",1501,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LodifySceneInfo",1505,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreDraw",693,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderOpaque",1227,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderTransp",1240,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderSelOpaque",1519,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderSelTransp",1532,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostDraw",820,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderAllPasses",1512,G__G__GL_167_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'vector<TGLScene::DrawElement_t*,allocator<TGLScene::DrawElement_t*> >' 'TGLScene::DrawElementPtrVec_t' 1 - elVec "
"g - 'Bool_t' 0 - check_timeout", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderElements",1437,G__G__GL_167_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'vector<TGLScene::DrawElement_t*,allocator<TGLScene::DrawElement_t*> >' 'TGLScene::DrawElementPtrVec_t' 1 - elVec "
"g - 'Bool_t' 0 - check_timeout U 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 10 '0' clipPlanes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResolveSelectRecord",1951,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLSelectRecord' - 1 - rec i - 'Int_t' 0 - curIdx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AdoptLogical",1203,G__G__GL_167_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLLogicalShape' - 1 - shape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyLogical",1445,G__G__GL_167_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - logid g - 'Bool_t' 0 'kTRUE' mustFind", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyLogicals",1560,G__G__GL_167_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLogical",1084,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 1, 1, 1, 8, "U 'TObject' - 0 - logid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AdoptPhysical",1333,G__G__GL_167_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLPhysicalShape' - 1 - shape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyPhysical",1575,G__G__GL_167_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - phid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyPhysicals",1690,G__G__GL_167_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindPhysical",1214,G__G__GL_167_0_29, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - phid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxPhysicalID",1552,G__G__GL_167_0_30, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginUpdate",1096,G__G__GL_167_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EndUpdate",890,G__G__GL_167_0_32, 121, -1, -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' minorChange g - 'Bool_t' 0 'kTRUE' sceneChanged "
"g - 'Bool_t' 0 'kTRUE' updateViewers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateLogical",1310,G__G__GL_167_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - logid", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePhysical",1440,G__G__GL_167_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - phid D - 'Double_t' 0 - trans "
"B - 'UChar_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePhysical",1440,G__G__GL_167_0_35, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - phid D - 'Double_t' 0 - trans "
"s - 'Color_t' 0 '-1' cidx b - 'UChar_t' 0 '0' transp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePhysioLogical",1946,G__G__GL_167_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - logid D - 'Double_t' 0 - trans "
"B - 'UChar_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePhysioLogical",1946,G__G__GL_167_0_37, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TObject' - 0 - logid D - 'Double_t' 0 - trans "
"s - 'Color_t' 0 - cidx b - 'UChar_t' 0 - transp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RefLogicalShapes",1596,G__G__GL_167_0_38, 117, G__get_linked_tagnum(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR), G__defined_typename("TGLScene::LogicalShapeMap_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginSmartRefresh",1723,G__G__GL_167_0_39, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndSmartRefresh",1517,G__G__GL_167_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindLogicalSmartRefresh",2322,G__G__GL_167_0_41, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 1, 1, 1, 8, "U 'TObject' - 0 - ID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGLCtxIdentity",1580,G__G__GL_167_0_42, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SizeOfScene",1086,G__G__GL_167_0_43, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpMapSizes",1218,G__G__GL_167_0_44, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RGBAFromColorIdx",1492,G__G__GL_167_0_45, 121, -1, -1, 0, 3, 3, 1, 0, 
"F - 'Float_t' 0 - rgba s - 'Color_t' 0 - ci "
"c - 'Char_t' 0 '0' transp", (char*)NULL, (void*) G__func2void( (void (*)(Float_t*, Color_t, Char_t))(&TGLScene::RGBAFromColorIdx) ), 0);
   G__memfunc_setup("IsOutside",921,G__G__GL_167_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 1, 0, 
"u 'TGLBoundingBox' - 11 - box u 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 11 - planes", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGLBoundingBox&, const TGLPlaneSet_t&))(&TGLScene::IsOutside) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_167_0_47, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLScene::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_167_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScene::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_167_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLScene::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_167_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLScene::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_167_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__GL_167_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScene::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_167_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLScene::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_167_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScene::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_167_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLScene::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLScene", 851, G__G__GL_167_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLogicalShape(void) {
   /* TGLLogicalShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 1, 1, 1, 4, 0, "u 'TGLLogicalShape' - 11 - -", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("PurgeDLRange",1152,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"h - 'UInt_t' 0 - base i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ref",285,G__G__GL_168_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRef",550,G__G__GL_168_0_8, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TGLPhysicalShape' - 0 - phys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SubRef",583,G__G__GL_168_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TGLPhysicalShape' - 0 - phys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StrongRef",922,G__G__GL_168_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 - strong", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyPhysicals",1690,G__G__GL_168_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnrefFirstPhysical",1861,G__G__GL_168_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstPhysical",1637,G__G__GL_168_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ID",141,G__G__GL_168_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExternal",1123,G__G__GL_168_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScene",782,G__G__GL_168_0_16, 85, G__get_linked_tagnum(&G__G__GLLN_TGLScene), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoundingBox",1119,G__G__GL_168_0_17, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateBoundingBox",1730,G__G__GL_168_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateBoundingBoxesOfPhysicals",3071,G__G__GL_168_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDLCache",912,G__G__GL_168_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - cached", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShouldDLCache",1235,G__G__GL_168_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 11 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLOffset",759,G__G__GL_168_0_22, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "s - 'Short_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLCacheClear",1099,G__G__GL_168_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLCacheDrop",1017,G__G__GL_168_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLCachePurge",1127,G__G__GL_168_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportedLODAxes",1590,G__G__GL_168_0_26, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QuantizeShapeLOD",1569,G__G__GL_168_0_27, 115, -1, G__defined_typename("Short_t"), 0, 2, 1, 1, 8, 
"s - 'Short_t' 0 - shapeLOD s - 'Short_t' 0 - combiLOD", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__GL_168_0_28, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,G__G__GL_168_0_29, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", "Actual draw method (non DL cached)", (void*) NULL, 3);
   G__memfunc_setup("DrawHighlight",1318,G__G__GL_168_0_30, 121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TGLPhysicalShape' - 10 - pshp "
"i - 'Int_t' 0 '-1' lvl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreSizeForOfInterest",2345,G__G__GL_168_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeepDuringSmartRefresh",2244,G__G__GL_168_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,G__G__GL_168_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlwaysSecondarySelect",2169,G__G__GL_168_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,G__G__GL_168_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvokeContextMenu",1766,G__G__GL_168_0_36, 121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TContextMenu' - 1 - menu h - 'UInt_t' 0 - x "
"h - 'UInt_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_168_0_37, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLogicalShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_168_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLogicalShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_168_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLogicalShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_168_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLogicalShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_168_0_41, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_168_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_168_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_168_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_168_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLogicalShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_168_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLogicalShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_168_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLogicalShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_168_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLogicalShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLLogicalShape", 1553, G__G__GL_168_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLObject(void) {
   /* TGLObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLObject));
   G__memfunc_setup("SearchGLRenderer",1568,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 1, 3, 4, 0, "U 'TClass' - 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModelCheckClass",1777,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"U 'TObject' - 0 - obj U 'TClass' - 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxisAlignedBBox",1760,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"f - 'Float_t' 0 - xmin f - 'Float_t' 0 - xmax "
"f - 'Float_t' 0 - ymin f - 'Float_t' 0 - ymax "
"f - 'Float_t' 0 - zmin f - 'Float_t' 0 - zmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxisAlignedBBox",1760,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "F - 'Float_t' 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShouldDLCache",1235,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 11 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeepDuringSmartRefresh",2244,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateBoundingBox",1730,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,G__G__GL_205_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBBox",663,G__G__GL_205_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetGLRenderer",1258,G__G__GL_205_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 1, 3, 1, 0, "U 'TClass' - 0 - isa", (char*)NULL, (void*) G__func2void( (TClass* (*)(TClass*))(&TGLObject::GetGLRenderer) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_205_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_205_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_205_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_205_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_205_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__GL_205_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_205_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_205_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_205_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLObject::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLObject", 956, G__G__GL_205_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLManip(void) {
   /* TGLManip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManip));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLManip), -1, 1, 1, 1, 2, 0, "u 'TGLManip' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcDrawScale",1257,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 8, 
"u 'TGLBoundingBox' - 11 - box u 'TGLCamera' - 11 - camera "
"d - 'Double_t' 1 - base U 'TGLVector3' - 0 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorFor",806,(G__InterfaceMethod) NULL, 66, -1, G__defined_typename("UChar_t"), 0, 1, 1, 2, 9, "h - 'UInt_t' 0 - widget", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedWidget",1709,G__G__GL_225_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelectedWidget",1721,G__G__GL_225_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActive",892,G__G__GL_225_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActive",904,G__G__GL_225_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Attach",597,G__G__GL_225_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttached",1086,G__G__GL_225_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,G__G__GL_225_0_13, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Select",608,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLCamera' - 11 - - u 'TGLRect' - 11 - - "
"u 'TGLBoundingBox' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,G__G__GL_225_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,G__G__GL_225_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_225_0_17, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLManip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_225_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_225_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLManip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_225_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLManip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_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__GL_225_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_225_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLManip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_225_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_225_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLManip::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLManip", 858, G__G__GL_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_memfuncTGLContext(void) {
   /* TGLContext */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLContext));
   G__memfunc_setup("TGLContext",972,G__G__GL_229_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 0, 3, 1, 1, 0, 
"U 'TGLWidget' - 0 - glWidget g - 'Bool_t' 0 'kTRUE' shareDefault "
"U 'TGLContext' - 10 '0' shareList", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIdentity",1130,G__G__GL_229_0_2, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCurrent",1121,G__G__GL_229_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearCurrent",1226,G__G__GL_229_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwapBuffers",1128,G__G__GL_229_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetContext",1041,G__G__GL_229_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLWidget' - 0 - widget U 'TGLContext' - 10 - shareList", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__GL_229_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__GL_229_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrent",1027,G__G__GL_229_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLContext* (*)())(&TGLContext::GetCurrent) ), 0);
   G__memfunc_setup("GlewInit",803,G__G__GL_229_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLContext::GlewInit) ), 0);
   G__memfunc_setup("TGLContext",972,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 0, 1, 1, 4, 0, "u 'TGLContext' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 1, 1, 1, 4, 0, "u 'TGLContext' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_229_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLContext::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_229_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLContext::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_229_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLContext::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_229_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLContext::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_229_0_17, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_229_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_229_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_229_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__GL_229_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLContext::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_229_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLContext::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_229_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLContext::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_229_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLContext::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLContext", 1098, G__G__GL_229_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLFormat(void) {
   /* TGLFormat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFormat));
   G__memfunc_setup("GetDefaultSamples",1722,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitAvailableSamples",2026,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFormat",848,G__G__GL_230_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFormat",848,G__G__GL_230_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 0, 1, 1, 1, 0, "i 'TGLFormat::EFormatOptions' - 0 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__GL_230_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLFormat' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__GL_230_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLFormat' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDepthSize",1200,G__G__GL_230_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDepthSize",1212,G__G__GL_230_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasDepth",785,G__G__GL_230_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStencilSize",1421,G__G__GL_230_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStencilSize",1433,G__G__GL_230_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - stencil", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasStencil",1006,G__G__GL_230_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAccumSize",1188,G__G__GL_230_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAccumSize",1200,G__G__GL_230_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - accum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAccumBuffer",1375,G__G__GL_230_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDoubleBuffered",1594,G__G__GL_230_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDoubleBuffered",1706,G__G__GL_230_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - db", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStereo",814,G__G__GL_230_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStereo",926,G__G__GL_230_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - db", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSamples",1013,G__G__GL_230_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSamples",1025,G__G__GL_230_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - samples", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasMultiSampling",1634,G__G__GL_230_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_230_0_23, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLFormat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_230_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFormat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_230_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLFormat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_230_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLFormat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_230_0_27, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_230_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_230_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_230_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__GL_230_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFormat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_230_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFormat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_230_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFormat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_230_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFormat::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLFormat", 848, G__G__GL_230_0_35, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 0, 1, 1, 1, 0, "u 'TGLFormat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLFormat", 974, G__G__GL_230_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_230_0_37, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 1, 1, 1, 1, 0, "u 'TGLFormat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPlotBox(void) {
   /* TGLPlotBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox));
   G__memfunc_setup("TGLPlotBox",943,G__G__GL_233_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox), -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 - xoySelectable g - 'Bool_t' 0 - xozSelectable "
"g - 'Bool_t' 0 - yozSelectable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBox",695,G__G__GL_233_0_2, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - selectedPart g - 'Bool_t' 0 - selectionPass "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - zLevels g - 'Bool_t' 0 - highColor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlotBox",1012,G__G__GL_233_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'pair<double,double>' 'Rgl::Range_t' 11 - xRange u 'pair<double,double>' 'Rgl::Range_t' 11 - yRange "
"u 'pair<double,double>' 'Rgl::Range_t' 11 - zRange", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlotBox",1012,G__G__GL_233_0_4, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'pair<double,double>' 'Rgl::Range_t' 11 - xRange d - 'Double_t' 0 - rangeXU "
"u 'pair<double,double>' 'Rgl::Range_t' 11 - yRange d - 'Double_t' 0 - rangeYU "
"u 'pair<double,double>' 'Rgl::Range_t' 11 - zRange d - 'Double_t' 0 - rangeZU", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameColor",1302,G__G__GL_233_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TColor' - 10 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindFrontPoint",1428,G__G__GL_233_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrontPoint",1331,G__G__GL_233_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get3DBox",704,G__G__GL_233_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get2DBox",703,G__G__GL_233_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TGLVertex3), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBackPlane",1263,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"i - 'Int_t' 0 - plane g - 'Bool_t' 0 - selectionPass "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - zLevels", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_233_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPlotBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_233_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_233_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPlotBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_233_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPlotBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_233_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_233_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_233_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_233_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__GL_233_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_233_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_233_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_233_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotBox::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLPlotBox", 943, G__G__GL_233_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox), -1, 0, 1, 1, 1, 0, "u 'TGLPlotBox' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLPlotBox", 1069, G__G__GL_233_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPlotCamera(void) {
   /* TGLPlotCamera */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera));
   G__memfunc_setup("TGLPlotCamera",1231,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera), -1, 0, 1, 1, 4, 0, "u 'TGLPlotCamera' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera), -1, 1, 1, 1, 4, 0, "u 'TGLPlotCamera' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLPlotCamera",1231,G__G__GL_234_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPlotCamera), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewport",1164,G__G__GL_234_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRect' - 11 - vp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetViewVolume",1343,G__G__GL_234_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLVertex3' - 10 - box", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartRotation",1374,G__G__GL_234_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateCamera",1208,G__G__GL_234_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartPan",813,G__G__GL_234_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Pan",287,G__G__GL_234_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZoomIn",604,G__G__GL_234_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZoomOut",733,G__G__GL_234_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCamera",885,G__G__GL_234_0_12, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__GL_234_0_13, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewportChanged",1546,G__G__GL_234_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__GL_234_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__GL_234_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWidth",800,G__G__GL_234_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeight",889,G__G__GL_234_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_234_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPlotCamera::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_234_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotCamera::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_234_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPlotCamera::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_234_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPlotCamera::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_234_0_23, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_234_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_234_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_234_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__GL_234_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotCamera::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_234_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotCamera::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_234_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotCamera::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_234_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotCamera::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPlotCamera", 1357, G__G__GL_234_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGL5DDataSet(void) {
   /* TGL5DDataSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet));
   G__memfunc_setup("TGL5DDataSet",1030,G__G__GL_235_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet), -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - inputData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRealPainter",1399,G__G__GL_235_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TGL5DPainter), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectPoints",1245,G__G__GL_235_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v4Level d - 'Double_t' 0 - range", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectedSize",1220,G__G__GL_235_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V1",135,G__G__GL_235_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V2",136,G__G__GL_235_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V3",137,G__G__GL_235_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXAxis",781,G__G__GL_235_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYAxis",782,G__G__GL_235_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZAxis",783,G__G__GL_235_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXRange",869,G__G__GL_235_0_15, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYRange",870,G__G__GL_235_0_16, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZRange",871,G__G__GL_235_0_17, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetV4Range",919,G__G__GL_235_0_18, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V1ToUnitCube",1129,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - v1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V2ToUnitCube",1130,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V3ToUnitCube",1131,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - v3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGL5DDataSet",1030,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet), -1, 0, 1, 1, 4, 0, "u 'TGL5DDataSet' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSet), -1, 1, 1, 1, 4, 0, "u 'TGL5DDataSet' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_235_0_24, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGL5DDataSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_235_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGL5DDataSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_235_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGL5DDataSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_235_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGL5DDataSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_235_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_235_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGL5DDataSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_235_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGL5DDataSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_235_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGL5DDataSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_235_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGL5DDataSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGL5DDataSet", 1156, G__G__GL_235_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLBoxCut(void) {
   /* TGLBoxCut */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut));
   G__memfunc_setup("TGLBoxCut",828,G__G__GL_239_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut), -1, 0, 1, 1, 1, 0, "U 'TGLPlotBox' - 10 - plotBox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TurnOnOff",897,G__G__GL_239_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__GL_239_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActive",904,G__G__GL_239_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetBoxGeometry",1656,G__G__GL_239_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFactor",907,G__G__GL_239_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawBox",695,G__G__GL_239_0_7, 121, -1, -1, 0, 2, 1, 1, 8, 
"g - 'Bool_t' 0 - selectionPass i - 'Int_t' 0 - selected", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartMovement",1369,G__G__GL_239_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveBox",704,G__G__GL_239_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py "
"i - 'Int_t' 0 - axisID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInCut",671,G__G__GL_239_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 1, 8, 
"d - 'Double_t' 0 - xMin d - 'Double_t' 0 - xMax "
"d - 'Double_t' 0 - yMin d - 'Double_t' 0 - yMax "
"d - 'Double_t' 0 - zMin d - 'Double_t' 0 - zMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXRange",869,G__G__GL_239_0_11, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYRange",870,G__G__GL_239_0_12, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZRange",871,G__G__GL_239_0_13, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustBox",916,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_239_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLBoxCut::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_239_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoxCut::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_239_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLBoxCut::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_239_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLBoxCut::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_239_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_239_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_239_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_239_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__GL_239_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoxCut::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_239_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBoxCut::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_239_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoxCut::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_239_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBoxCut::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLBoxCut", 828, G__G__GL_239_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLBoxCut), -1, 0, 1, 1, 1, 0, "u 'TGLBoxCut' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLBoxCut", 954, G__G__GL_239_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLTH3Slice(void) {
   /* TGLTH3Slice */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice));
   G__memfunc_setup("TGLTH3Slice",934,G__G__GL_240_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - sliceName U 'TH3' - 10 - hist "
"U 'TGLPlotCoordinates' - 10 - coord U 'TGLPlotBox' - 10 - box "
"i 'TGLTH3Slice::ESliceAxis' - 0 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLTH3Slice",934,G__G__GL_240_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTH3Slice), -1, 0, 6, 1, 1, 0, 
"u 'TString' - 11 - sliceName U 'TH3' - 10 - hist "
"U 'TF3' - 10 - fun U 'TGLPlotCoordinates' - 10 - coord "
"U 'TGLPlotBox' - 10 - box i 'TGLTH3Slice::ESliceAxis' - 0 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSlice",894,G__G__GL_240_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "d - 'Double_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSliceWidth",1308,G__G__GL_240_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' width", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMinMax",886,G__G__GL_240_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pair<double,double>' 'Rgl::Range_t' 11 - newRange", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPalette",1007,G__G__GL_240_0_6, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLevelPalette), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareTexCoords",1642,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"d - 'Double_t' 0 - pos i - 'Int_t' 0 - sliceBegin "
"i - 'Int_t' 0 - sliceEnd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMinMax",971,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"i - 'Int_t' 0 - sliceBegin i - 'Int_t' 0 - sliceEnd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreparePalette",1438,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSliceTextured",1747,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "d - 'Double_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSliceFrame",1385,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"i - 'Int_t' 0 - low i - 'Int_t' 0 - up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_240_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLTH3Slice::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_240_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3Slice::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_240_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLTH3Slice::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_240_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLTH3Slice::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_240_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__GL_240_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3Slice::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_240_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTH3Slice::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_240_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3Slice::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_240_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTH3Slice::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLTH3Slice", 1060, G__G__GL_240_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPlotPainter(void) {
   /* TGLPlotPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter));
   G__memfunc_setup("RefBackBox",951,G__G__GL_243_0_4, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlotBox), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGL",551,G__G__GL_243_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeInitGL",720,G__G__GL_243_0_6, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPlot",813,G__G__GL_243_0_7, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PlotSelected",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,G__G__GL_243_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StartPan",813,G__G__GL_243_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddOption",898,G__G__GL_243_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - stringOption", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessEvent",1249,G__G__GL_243_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPadColor",1088,G__G__GL_243_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TColor' - 10 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameColor",1302,G__G__GL_243_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TColor' - 10 - frameColor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvalidateSelection",1959,G__G__GL_243_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CutAxisSelected",1514,G__G__GL_243_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadColor",1076,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TColor), -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveSection",1132,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSections",1238,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPaletteAxis",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearBuffers",1204,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintPlot",940,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveModelviewMatrix",1968,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveProjectionMatrix",2081,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreModelviewMatrix",2309,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreProjectionMatrix",2422,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_243_0_31, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPlotPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_243_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_243_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPlotPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_243_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPlotPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_243_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__GL_243_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_243_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_243_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlotPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_243_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlotPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPlotPainter", 1495, G__G__GL_243_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPlot3D(void) {
   /* TGLPlot3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D), -1, 1, 1, 1, 4, 0, "u 'TGLPlot3D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetPainter",1023,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGLPlotPainter' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InstantiatePlot",1571,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D), -1, 0, 1, 3, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KeepDuringSmartRefresh",2244,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePlot",1011,G__G__GL_249_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D), -1, 0, 3, 3, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt "
"U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) G__func2void( (TGLPlot3D* (*)(TObject*, Option_t*, TVirtualPad*))(&TGLPlot3D::CreatePlot) ), 0);
   G__memfunc_setup("CreatePlot",1011,G__G__GL_249_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPlot3D), -1, 0, 5, 3, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt "
"g - 'Bool_t' 0 - logx g - 'Bool_t' 0 - logy "
"g - 'Bool_t' 0 - logz", (char*)NULL, (void*) G__func2void( (TGLPlot3D* (*)(TObject*, Option_t*, Bool_t, Bool_t, Bool_t))(&TGLPlot3D::CreatePlot) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_249_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPlot3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_249_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlot3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_249_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPlot3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_249_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPlot3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_249_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__GL_249_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlot3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_249_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlot3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_249_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPlot3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_249_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPlot3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPlot3D", 891, G__G__GL_249_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTF2GL(void) {
   /* TF2GL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TF2GL));
   G__memfunc_setup("TF2GL",351,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TF2GL), -1, 0, 1, 1, 4, 0, "u 'TF2GL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TF2GL), -1, 1, 1, 1, 4, 0, "u 'TF2GL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TF2GL",351,G__G__GL_252_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TF2GL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeepDuringSmartRefresh",2244,(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__GL_252_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF2GL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_252_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF2GL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_252_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF2GL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_252_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF2GL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_252_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__GL_252_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF2GL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_252_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF2GL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_252_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF2GL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_252_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF2GL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TF2GL", 477, G__G__GL_252_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGL5DDataSetEditor(void) {
   /* TGL5DDataSetEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGL5DDataSetEditor",1645,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor), -1, 0, 1, 1, 4, 0, "u 'TGL5DDataSetEditor' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor), -1, 1, 1, 1, 4, 0, "u 'TGL5DDataSetEditor' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateStyleTab",1404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateGridTab",1265,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateIsoTab",1174,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStyleTabWidgets",1835,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridTabWidgets",1696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsoTabWidgets",1605,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableGridTabButtons",2003,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableGridTabButtons",2112,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableSurfaceControls",2148,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableSurfaceControls",2257,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGL5DDataSetEditor",1645,G__G__GL_351_0_14, 105, G__get_linked_tagnum(&G__G__GLLN_TGL5DDataSetEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GridParametersChanged",2116,G__G__GL_351_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XSliderChanged",1381,G__G__GL_351_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("YSliderChanged",1382,G__G__GL_351_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZSliderChanged",1383,G__G__GL_351_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XSliderSetMin",1291,G__G__GL_351_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("XSliderSetMax",1293,G__G__GL_351_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("YSliderSetMin",1292,G__G__GL_351_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("YSliderSetMax",1294,G__G__GL_351_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZSliderSetMin",1293,G__G__GL_351_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZSliderSetMax",1295,G__G__GL_351_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RollbackGridParameters",2244,G__G__GL_351_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyGridParameters",1952,G__G__GL_351_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HighlightClicked",1607,G__G__GL_351_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SurfaceSelected",1522,G__G__GL_351_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VisibleClicked",1405,G__G__GL_351_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorChanged",1193,G__G__GL_351_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pixelColor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AlphaChanged",1168,G__G__GL_351_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveSurface",1335,G__G__GL_351_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNewSurface",1276,G__G__GL_351_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyAlpha",1004,G__G__GL_351_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyPlanes",1129,G__G__GL_351_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoxCutToggled",1307,G__G__GL_351_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AlphaChanged",1168,G__G__GL_351_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NContoursChanged",1621,G__G__GL_351_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_351_0_40, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGL5DDataSetEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_351_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGL5DDataSetEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_351_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGL5DDataSetEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_351_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGL5DDataSetEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_351_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_351_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGL5DDataSetEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_351_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGL5DDataSetEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_351_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGL5DDataSetEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_351_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGL5DDataSetEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGL5DDataSetEditor", 1771, G__G__GL_351_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLParametricEquation(void) {
   /* TGLParametricEquation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation));
   G__memfunc_setup("TGLParametricEquation",2101,G__G__GL_355_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation), -1, 0, 8, 1, 1, 0, 
"u 'TString' - 11 - name u 'TString' - 11 - xEquation "
"u 'TString' - 11 - yEquation u 'TString' - 11 - zEquation "
"d - 'Double_t' 0 - uMin d - 'Double_t' 0 - uMax "
"d - 'Double_t' 0 - vMin d - 'Double_t' 0 - vMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLParametricEquation",2101,G__G__GL_355_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation), -1, 0, 6, 1, 1, 0, 
"u 'TString' - 11 - name Y - 'ParametricEquation_t' 0 - equation "
"d - 'Double_t' 0 - uMin d - 'Double_t' 0 - uMax "
"d - 'Double_t' 0 - vMin d - 'Double_t' 0 - vMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetURange",866,G__G__GL_355_0_3, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVRange",867,G__G__GL_355_0_4, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEdoublecOdoublegR), G__defined_typename("Rgl::Range_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsConstrained",1334,G__G__GL_355_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConstrained",1446,G__G__GL_355_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsModified",989,G__G__GL_355_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModified",1101,G__G__GL_355_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalVertex",1030,G__G__GL_355_0_9, 121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLVertex3' - 1 - newVertex d - 'Double_t' 0 - u "
"d - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLParametricEquation",2101,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation), -1, 0, 1, 1, 4, 0, "u 'TGLParametricEquation' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquation), -1, 1, 1, 1, 4, 0, "u 'TGLParametricEquation' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_355_0_16, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLParametricEquation::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_355_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricEquation::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_355_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLParametricEquation::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_355_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLParametricEquation::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_355_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__GL_355_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricEquation::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_355_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLParametricEquation::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_355_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricEquation::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_355_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLParametricEquation::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLParametricEquation", 2227, G__G__GL_355_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLTH3Composition(void) {
   /* TGLTH3Composition */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition));
   G__memfunc_setup("TGLTH3Composition",1610,G__G__GL_356_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition), -1, 0, 0, 1, 1, 0, "", "I need it only because of explicit private copy ctor.", (void*) NULL, 0);
   G__memfunc_setup("AddTH3",472,G__G__GL_356_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH3' - 10 - hist i 'TGLTH3Composition::ETH3BinShape' - 0 'kBox' shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckRanges",1086,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TH3' - 10 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLTH3Composition",1610,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition), -1, 0, 1, 1, 4, 0, "u 'TGLTH3Composition' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLTH3Composition), -1, 1, 1, 1, 4, 0, "u 'TGLTH3Composition' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_356_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLTH3Composition::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_356_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3Composition::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_356_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLTH3Composition::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_356_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLTH3Composition::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_356_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__GL_356_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3Composition::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_356_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTH3Composition::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_356_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3Composition::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_356_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTH3Composition::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLTH3Composition", 1736, G__G__GL_356_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLHistPainter(void) {
   /* TGLHistPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter));
   G__memfunc_setup("TGLHistPainter",1362,G__G__GL_357_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter), -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLHistPainter",1362,G__G__GL_357_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter), -1, 0, 1, 1, 1, 0, "U 'TGLParametricEquation' - 0 - equation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLHistPainter",1362,G__G__GL_357_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter), -1, 0, 1, 1, 1, 0, "U 'TGL5DDataSet' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLHistPainter",1362,G__G__GL_357_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter), -1, 0, 1, 1, 1, 0, "U 'TGLTH3Composition' - 0 - comp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPanel",894,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContourList",1446,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TList), -1, 0, 1, 1, 1, 8, "d - 'Double_t' 0 - contour", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStack",790,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintStat",920,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - dostat U 'TF1' - 0 - fit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - message U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHistogram",1242,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - hist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStack",802,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - stack", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCuts",797,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 0 - cutsOpt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShowProjection",1770,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - option i - 'Int_t' 0 - nbins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRealPainter",1399,G__G__GL_357_0_20, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPlotPainter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParsePaintOption",1648,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLHistPaintercLcLPlotOption_t), -1, 0, 1, 1, 4, 8, "u 'TString' - 11 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreatePainter",1319,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TGLHistPainter::PlotOption_t' - 11 - parsed u 'TString' - 11 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PadToViewport",1336,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kFALSE' selectionPass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLHistPainter",1362,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter), -1, 0, 1, 1, 4, 0, "u 'TGLHistPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLHistPainter), -1, 1, 1, 1, 4, 0, "u 'TGLHistPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_357_0_26, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLHistPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_357_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLHistPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_357_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLHistPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_357_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLHistPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_357_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__GL_357_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLHistPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_357_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLHistPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_357_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLHistPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_357_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLHistPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLHistPainter", 1488, G__G__GL_357_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLAdapter(void) {
   /* TGLAdapter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAdapter));
   G__memfunc_setup("TGLAdapter",936,G__G__GL_368_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAdapter), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 '-1' glDevice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCurrent",1121,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SwapBuffers",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPixelFormat",1419,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContext",1029,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGLDevice",1039,G__G__GL_368_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - glDevice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadGLBuffer",1129,G__G__GL_368_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectOffScreenDevice",2091,G__G__GL_368_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarkForDirectCopy",1704,G__G__GL_368_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isDirect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExtractViewport",1595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - vp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLAdapter",936,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAdapter), -1, 0, 1, 1, 4, 0, "u 'TGLAdapter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLAdapter), -1, 1, 1, 1, 4, 0, "u 'TGLAdapter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddContext",1006,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGLContext' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveContext",1363,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGLContext' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_368_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLAdapter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_368_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAdapter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_368_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLAdapter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_368_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLAdapter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_368_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__GL_368_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAdapter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_368_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAdapter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_368_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAdapter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_368_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAdapter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLAdapter", 1062, G__G__GL_368_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLOvlSelectRecord(void) {
   /* TGLOvlSelectRecord */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord));
   G__memfunc_setup("TGLOvlSelectRecord",1751,G__G__GL_369_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLOvlSelectRecord",1751,G__G__GL_369_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord), -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLOvlSelectRecord",1751,G__G__GL_369_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord), -1, 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 11 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_369_0_4, 117, G__get_linked_tagnum(&G__G__GLLN_TGLOvlSelectRecord), -1, 1, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 11 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOvlElement",1307,G__G__GL_369_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOvlElement",1319,G__G__GL_369_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLOverlayElement' - 0 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_369_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLOvlSelectRecord::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_369_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOvlSelectRecord::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_369_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLOvlSelectRecord::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_369_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOvlSelectRecord::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_369_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__GL_369_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOvlSelectRecord::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_369_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOvlSelectRecord::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_369_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOvlSelectRecord::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_369_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOvlSelectRecord::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLOvlSelectRecord", 1877, G__G__GL_369_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLOverlayElement(void) {
   /* TGLOverlayElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElement), -1, 1, 1, 1, 4, 0, "u 'TGLOverlayElement' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ProjectionMatrixPushIdentity",2940,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MouseEnter",1031,G__G__GL_370_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseStillInside",1645,G__G__GL_370_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,G__G__GL_370_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,G__G__GL_370_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,G__G__GL_370_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRole",690,G__G__GL_370_0_10, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLERole), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRole",702,G__G__GL_370_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLOverlayElement::ERole' - 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetState",801,G__G__GL_370_0_12, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayElementcLcLEState), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetState",813,G__G__GL_370_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLOverlayElement::EState' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinaryState",1426,G__G__GL_370_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_370_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLOverlayElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_370_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_370_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLOverlayElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_370_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOverlayElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_370_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_370_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_370_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_370_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__GL_370_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_370_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOverlayElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_370_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_370_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOverlayElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLOverlayElement", 1809, G__G__GL_370_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLOverlayList(void) {
   /* TGLOverlayList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayList));
   G__memfunc_setup("TGLOverlayList",1381,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayList), -1, 0, 1, 1, 4, 0, "u 'TGLOverlayList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayList), -1, 1, 1, 1, 4, 0, "u 'TGLOverlayList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLOverlayList",1381,G__G__GL_373_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_373_0_4, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLOverlayList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_373_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_373_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLOverlayList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_373_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOverlayList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_373_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_373_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_373_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_373_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__GL_373_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_373_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOverlayList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_373_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_373_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOverlayList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLOverlayList", 1507, G__G__GL_373_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLFontManager(void) {
   /* TGLFontManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFontManager));
   G__memfunc_setup("TGLFontManager",1337,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFontManager), -1, 0, 1, 1, 4, 0, "u 'TGLFontManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLFontManager), -1, 1, 1, 1, 4, 0, "u 'TGLFontManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitStatics",1135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFontManager",1337,G__G__GL_380_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFontManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterFont",1244,G__G__GL_380_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 0 - file "
"i 'TGLFont::EMode' - 0 - mode u 'TGLFont' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterFont",1244,G__G__GL_380_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - size C - - 10 - name "
"i 'TGLFont::EMode' - 0 - mode u 'TGLFont' - 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseFont",1112,G__G__GL_380_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLFont' - 1 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontFileArray",1590,G__G__GL_380_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TObjArray), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObjArray* (*)())(&TGLFontManager::GetFontFileArray) ), 0);
   G__memfunc_setup("GetFontSizeArray",1617,G__G__GL_380_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("TGLFontManager::FontSizeVec_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLFontManager::FontSizeVec_t* (*)())(&TGLFontManager::GetFontSizeArray) ), 0);
   G__memfunc_setup("GetFontSize",1106,G__G__GL_380_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i - 'Int_t' 0 - ds", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t))(&TGLFontManager::GetFontSize) ), 0);
   G__memfunc_setup("GetFontSize",1106,G__G__GL_380_0_11, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - ds i - 'Int_t' 0 - min "
"i - 'Int_t' 0 - max", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t, Int_t, Int_t))(&TGLFontManager::GetFontSize) ), 0);
   G__memfunc_setup("GetFontNameFromId",1657,G__G__GL_380_0_12, 67, -1, -1, 0, 1, 3, 1, 1, "i - 'Int_t' 0 - -", (char*)NULL, (void*) G__func2void( (const char* (*)(Int_t))(&TGLFontManager::GetFontNameFromId) ), 0);
   G__memfunc_setup("ClearFontTrash",1408,G__G__GL_380_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_380_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLFontManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_380_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFontManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_380_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLFontManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_380_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLFontManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_380_0_18, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_380_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_380_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_380_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__GL_380_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFontManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_380_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFontManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_380_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFontManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_380_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFontManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLFontManager", 1463, G__G__GL_380_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLFont(void) {
   /* TGLFont */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFont));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLFont), -1, 1, 1, 1, 4, 0, "u 'TGLFont' - 11 - o", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("TGLFont",638,G__G__GL_381_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFont), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFont",638,G__G__GL_381_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFont), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 0 - font "
"i 'TGLFont::EMode' - 0 - mode U 'FTFont' - 0 '0' f "
"U 'TGLFontManager' - 0 '0' mng", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFont",638,G__G__GL_381_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFont), -1, 0, 1, 1, 1, 0, "u 'TGLFont' - 11 - o", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("CopyAttributes",1474,G__G__GL_381_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLFont' - 11 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__GL_381_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFile",672,G__G__GL_381_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMode",677,G__G__GL_381_0_8, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrashCount",1323,G__G__GL_381_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrashCount",1335,G__G__GL_381_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncTrashCount",1317,G__G__GL_381_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFont",707,G__G__GL_381_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'FTFont' - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__GL_381_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_FTFont), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetManager",999,G__G__GL_381_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLFontManager' - 0 - mng", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetManager",987,G__G__GL_381_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TGLFontManager), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDepth",789,G__G__GL_381_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDepth",801,G__G__GL_381_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAscent",894,G__G__GL_381_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDescent",998,G__G__GL_381_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineHeight",1281,G__G__GL_381_0_20, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MeasureBaseLineParams",2105,G__G__GL_381_0_21, 121, -1, -1, 0, 4, 1, 1, 8, 
"f - 'Float_t' 1 - ascent f - 'Float_t' 1 - descent "
"f - 'Float_t' 1 - line_height C - - 10 '\"Xj\"' txt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BBox",363,G__G__GL_381_0_22, 121, -1, -1, 0, 7, 1, 1, 8, 
"C - - 10 - txt f - 'Float_t' 1 - llx "
"f - 'Float_t' 1 - lly f - 'Float_t' 1 - llz "
"f - 'Float_t' 1 - urx f - 'Float_t' 1 - ury "
"f - 'Float_t' 1 - urz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,G__G__GL_381_0_23, 121, -1, -1, 0, 5, 1, 1, 8, 
"C - - 10 - txt d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - angle "
"d - 'Double_t' 0 - mgn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,G__G__GL_381_0_24, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - txt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,G__G__GL_381_0_25, 121, -1, -1, 0, 6, 1, 1, 8, 
"u 'TString' - 11 - txt f - 'Float_t' 0 - x "
"f - 'Float_t' 0 - y f - 'Float_t' 0 - z "
"i 'TGLFont::ETextAlignH_e' - 0 - alignH i 'TGLFont::ETextAlignV_e' - 0 - alignV", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreRender",903,G__G__GL_381_0_26, 121, -1, -1, 0, 2, 1, 1, 8, 
"g - 'Bool_t' 0 'kTRUE' autoLight g - 'Bool_t' 0 'kFALSE' lightOn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostRender",1030,G__G__GL_381_0_27, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator<",936,G__G__GL_381_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLFont' - 11 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_381_0_29, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLFont::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_381_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFont::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_381_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLFont::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_381_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLFont::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_381_0_33, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_381_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_381_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_381_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_381_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFont::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_381_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFont::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_381_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFont::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_381_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFont::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLFont", 764, G__G__GL_381_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLViewerBase(void) {
   /* TGLViewerBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase));
   G__memfunc_setup("TGLViewerBase",1236,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 0, 1, 1, 4, 0, "u 'TGLViewerBase' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 1, 1, 1, 4, 0, "u 'TGLViewerBase' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("FindScene",879,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator), G__defined_typename("TGLViewerBase::SceneInfoList_i"), 0, 1, 1, 2, 0, "U 'TGLSceneBase' - 0 - scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SubRenderScenes",1515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "a - 'TGLViewerBase::SubRender_foo' 0 - render_foo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupClipObject",1520,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLViewerBase",1236,G__G__GL_402_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LockIdStr",879,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddScene",759,G__G__GL_402_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 1, 1, 1, 0, "U 'TGLSceneBase' - 0 - scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveScene",1116,G__G__GL_402_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLSceneBase' - 0 - scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveAllScenes",1512,G__G__GL_402_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneDestructing",1658,G__G__GL_402_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLSceneBase' - 0 - scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSceneInfo",1178,G__G__GL_402_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 1, 1, 1, 0, "U 'TGLSceneBase' - 0 - scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindLogicalInScenes",1876,G__G__GL_402_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOverlayElement",1717,G__G__GL_402_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLOverlayElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveOverlayElement",2074,G__G__GL_402_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLOverlayElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteOverlayAnnotations",2499,G__G__GL_402_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteOverlayElements",2162,G__G__GL_402_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLOverlayElement::ERole' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clip",392,G__G__GL_402_0_18, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClip",692,G__G__GL_402_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LOD",223,G__G__GL_402_0_20, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLOD",523,G__G__GL_402_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - lod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Style",529,G__G__GL_402_0_22, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStyle",829,G__G__GL_402_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WFLineW",636,G__G__GL_402_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWFLineW",936,G__G__GL_402_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OLLineW",634,G__G__GL_402_0_26, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOLLineW",934,G__G__GL_402_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetSceneInfos",1520,G__G__GL_402_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Changed",682,G__G__GL_402_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsChanged",870,G__G__GL_402_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MergeSceneBBoxes",1569,G__G__GL_402_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 1 - bbox", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreRender",903,G__G__GL_402_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,G__G__GL_402_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderNonSelected",1716,G__G__GL_402_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderSelected",1417,G__G__GL_402_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderOverlay",1346,G__G__GL_402_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - state g - 'Bool_t' 0 - selection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostRender",1030,G__G__GL_402_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreRenderOverlaySelection",2575,G__G__GL_402_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostRenderOverlaySelection",2702,G__G__GL_402_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResolveSelectRecord",1951,G__G__GL_402_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLSelectRecord' - 1 - rec i - 'Int_t' 0 - recIdx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindClosestRecord",1725,G__G__GL_402_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLSelectRecord' - 1 - rec i - 'Int_t' 1 - recIdx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindClosestOpaqueRecord",2344,G__G__GL_402_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLSelectRecord' - 1 - rec i - 'Int_t' 1 - recIdx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindClosestOverlayRecord",2463,G__G__GL_402_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TGLOvlSelectRecord' - 1 - rec i - 'Int_t' 1 - recIdx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrCtx",897,G__G__GL_402_0_44, 85, G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RnrCtx",609,G__G__GL_402_0_45, 117, G__get_linked_tagnum(&G__G__GLLN_TGLRnrCtx), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_402_0_46, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLViewerBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_402_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewerBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_402_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLViewerBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_402_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLViewerBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_402_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_402_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewerBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_402_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLViewerBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_402_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewerBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_402_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLViewerBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLViewerBase", 1362, G__G__GL_402_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLAnnotation(void) {
   /* TGLAnnotation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation));
   G__memfunc_setup("TGLAnnotation",1282,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation), -1, 0, 1, 1, 4, 0, "u 'TGLAnnotation' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation), -1, 1, 1, 1, 4, 0, "u 'TGLAnnotation' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeEditor",997,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineTransparency",1954,(G__InterfaceMethod) NULL, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLAnnotation",1282,G__G__GL_404_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation), -1, 0, 4, 1, 1, 0, 
"U 'TGLViewerBase' - 0 - parent C - - 10 - text "
"f - 'Float_t' 0 - posx f - 'Float_t' 0 - posy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLAnnotation",1282,G__G__GL_404_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAnnotation), -1, 0, 5, 1, 1, 0, 
"U 'TGLViewerBase' - 0 - parent C - - 10 - text "
"f - 'Float_t' 0 - posx f - 'Float_t' 0 - posy "
"u 'TGLVector3' - 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__GL_404_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__GL_404_0_8, 117, G__get_linked_tagnum(&G__G__GLLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransparency",1574,G__G__GL_404_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransparency",1562,G__G__GL_404_0_10, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseColorSet",1412,G__G__GL_404_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseColorSet",1400,G__G__GL_404_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackColor",1180,G__G__GL_404_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBackColor",1168,G__G__GL_404_0_14, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextColor",1232,G__G__GL_404_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextColor",1220,G__G__GL_404_0_16, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextSize",1132,G__G__GL_404_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextSize",1120,G__G__GL_404_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAllowClose",1313,G__G__GL_404_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllowClose",1301,G__G__GL_404_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTextAlign",1200,G__G__GL_404_0_21, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLETextAlignH_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextAlign",1212,G__G__GL_404_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLFont::ETextAlignH_e' - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MouseEnter",1031,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseEditor",1117,G__G__GL_404_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateText",1032,G__G__GL_404_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_404_0_29, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLAnnotation::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_404_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAnnotation::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_404_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLAnnotation::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_404_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLAnnotation::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_404_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_404_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAnnotation::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_404_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAnnotation::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_404_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAnnotation::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_404_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAnnotation::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLAnnotation", 1408, G__G__GL_404_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLAutoRotator(void) {
   /* TGLAutoRotator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator));
   G__memfunc_setup("TGLAutoRotator",1387,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator), -1, 0, 1, 1, 4, 0, "u 'TGLAutoRotator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator), -1, 1, 1, 1, 4, 0, "u 'TGLAutoRotator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLAutoRotator",1387,G__G__GL_408_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAutoRotator), -1, 0, 1, 1, 1, 0, "U 'TGLViewer' - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCamera",873,G__G__GL_408_0_4, 85, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Start",526,G__G__GL_408_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Stop",422,G__G__GL_408_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Timeout",743,G__G__GL_408_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRunning",925,G__G__GL_408_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDt",472,G__G__GL_408_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDt",484,G__G__GL_408_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWPhi",664,G__G__GL_408_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWPhi",676,G__G__GL_408_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWTheta",877,G__G__GL_408_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWTheta",889,G__G__GL_408_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetATheta",855,G__G__GL_408_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetATheta",867,G__G__GL_408_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWDolly",891,G__G__GL_408_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWDolly",903,G__G__GL_408_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADolly",869,G__G__GL_408_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetADolly",881,G__G__GL_408_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_408_0_21, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLAutoRotator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_408_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAutoRotator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_408_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLAutoRotator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_408_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLAutoRotator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_408_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__GL_408_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAutoRotator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_408_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAutoRotator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_408_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAutoRotator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_408_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAutoRotator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLAutoRotator", 1513, G__G__GL_408_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLText(void) {
   /* TGLText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLText));
   G__memfunc_setup("TGLText",652,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLText), -1, 0, 1, 1, 4, 0, "u 'TGLText' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLText), -1, 1, 1, 1, 4, 0, "u 'TGLText' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLText",652,G__G__GL_409_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLText",652,G__G__GL_409_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLText), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFont",695,G__G__GL_409_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_FTFont), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGLTextAngles",1470,G__G__GL_409_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - a1 d - 'Double_t' 0 - a2 "
"d - 'Double_t' 0 - a3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGLTextFont",1275,G__G__GL_409_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 - fontnumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintGLText",1076,G__G__GL_409_0_8, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintBBox",871,G__G__GL_409_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BBox",363,G__G__GL_409_0_10, 121, -1, -1, 0, 7, 1, 1, 0, 
"C - - 10 - string f - - 1 - llx "
"f - - 1 - lly f - - 1 - llz "
"f - - 1 - urx f - - 1 - ury "
"f - - 1 - urz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_409_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_409_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_409_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_409_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_409_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__GL_409_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_409_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_409_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_409_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLText::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLText", 778, G__G__GL_409_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLAxis(void) {
   /* TGLAxis */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxis));
   G__memfunc_setup("TGLAxis",636,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAxis), -1, 0, 1, 1, 4, 0, "u 'TGLAxis' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLAxis), -1, 1, 1, 1, 4, 0, "u 'TGLAxis' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLAxis",636,G__G__GL_410_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintGLAxis",1060,G__G__GL_410_0_4, 121, -1, -1, 0, 6, 1, 1, 0, 
"D - 'Double_t' 10 - p1 D - 'Double_t' 10 - p2 "
"d - 'Double_t' 0 - wmin d - 'Double_t' 0 - wmax "
"i - 'Int_t' 0 - ndiv C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__GL_410_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintGLAxisBody",1458,G__G__GL_410_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintGLAxisTickMarks",1965,G__G__GL_410_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintGLAxisLabels",1655,G__G__GL_410_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TicksPositions",1478,G__G__GL_410_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TicksPositionsNoOpt",1974,G__G__GL_410_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TicksPositionsOpt",1785,G__G__GL_410_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoLabels",774,G__G__GL_410_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTickMarksLength",1815,G__G__GL_410_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTickMarksOrientation",2369,G__G__GL_410_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tmo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelsOffset",1510,G__G__GL_410_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelsSize",1306,G__G__GL_410_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridLength",1300,G__G__GL_410_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - grid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelsAngles",1497,G__G__GL_410_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - a1 d - 'Double_t' 0 - a2 "
"d - 'Double_t' 0 - a3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_410_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLAxis::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_410_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxis::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_410_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLAxis::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_410_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLAxis::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_410_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__GL_410_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxis::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_410_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAxis::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_410_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxis::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_410_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAxis::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLAxis", 762, G__G__GL_410_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLAxisPainter(void) {
   /* TGLAxisPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter));
   G__memfunc_setup("TGLAxisPainter",1359,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter), -1, 0, 1, 1, 4, 0, "u 'TGLAxisPainter' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter), -1, 1, 1, 1, 4, 0, "u 'TGLAxisPainter' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("LabelsLimits",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"C - - 10 - label i - 'Int_t' 1 - first "
"i - 'Int_t' 1 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FormAxisValue",1318,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"d - 'Double_t' 0 - x u 'TString' - 1 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLAxisPainter",1359,G__G__GL_412_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTMNDim",809,G__G__GL_412_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTMNDim",821,G__G__GL_412_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefDir",572,G__G__GL_412_0_8, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefTMOff",729,G__G__GL_412_0_9, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontMode",1084,G__G__GL_412_0_10, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFontcLcLEMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFontMode",1096,G__G__GL_412_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLFont::EMode' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelPixelFontSize",2112,G__G__GL_412_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - fs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabelPixelFontSize",2100,G__G__GL_412_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitlePixelFontSize",2146,G__G__GL_412_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - fs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitlePixelFontSize",2134,G__G__GL_412_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefTitlePos",1105,G__G__GL_412_0_16, 117, G__get_linked_tagnum(&G__G__GLLN_TGLVector3), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelAlign",1271,G__G__GL_412_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'TGLFont::ETextAlignH_e' - 0 - - i 'TGLFont::ETextAlignV_e' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefLabVec",842,G__G__GL_412_0_18, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR), G__defined_typename("TGLAxisPainter::LabVec_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefTMVec",732,G__G__GL_412_0_19, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR), G__defined_typename("TGLAxisPainter::TMVec_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttAxis",1002,G__G__GL_412_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TAttAxis' - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttAxis",990,G__G__GL_412_0_21, 85, G__get_linked_tagnum(&G__G__GLLN_TAttAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseAxisColors",1632,G__G__GL_412_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseAxisColors",1620,G__G__GL_412_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabelFont",1187,G__G__GL_412_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx C - - 10 - fontName "
"i - 'Int_t' 0 '64' pixelSize d - 'Double_t' 0 '-1' font3DSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitleFont",1221,G__G__GL_412_0_25, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx C - - 10 - fontName "
"i - 'Int_t' 0 '64' pixelSize d - 'Double_t' 0 '-1' font3DSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTextFormat",1338,G__G__GL_412_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max "
"d - 'Double_t' 0 - binWidth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RnrText",727,G__G__GL_412_0_27, 121, -1, -1, 0, 5, 1, 1, 8, 
"u 'TString' - 11 - txt u 'TGLVector3' - 11 - pos "
"i 'TGLFont::ETextAlignH_e' - 0 - aH i 'TGLFont::ETextAlignV_e' - 0 - aV "
"u 'TGLFont' - 11 - font", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RnrTitle",820,G__G__GL_412_0_28, 121, -1, -1, 0, 4, 1, 1, 8, 
"u 'TString' - 11 - title u 'TGLVector3' - 1 - pos "
"i 'TGLFont::ETextAlignH_e' - 0 - aH i 'TGLFont::ETextAlignV_e' - 0 - aV", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RnrLabels",901,G__G__GL_412_0_29, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RnrLines",813,G__G__GL_412_0_30, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintAxis",913,G__G__GL_412_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - ctx U 'TAxis' - 0 - ax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_412_0_32, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLAxisPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_412_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxisPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_412_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLAxisPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_412_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLAxisPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_412_0_36, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_412_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_412_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_412_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__GL_412_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxisPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_412_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAxisPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_412_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxisPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_412_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAxisPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLAxisPainter", 1485, G__G__GL_412_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLAxisPainterBox(void) {
   /* TGLAxisPainterBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainterBox));
   G__memfunc_setup("TGLAxisPainterBox",1656,G__G__GL_423_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLAxisPainterBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxis3DTitlePos",1644,G__G__GL_423_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawAxis3D",922,G__G__GL_423_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PlotStandard",1232,G__G__GL_423_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TH1' - 10 - histo "
"u 'TGLBoundingBox' - 11 - bbox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_423_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLAxisPainterBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_423_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxisPainterBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_423_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLAxisPainterBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_423_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLAxisPainterBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_423_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__GL_423_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxisPainterBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_423_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAxisPainterBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_423_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLAxisPainterBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_423_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLAxisPainterBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLAxisPainterBox", 1782, G__G__GL_423_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLBoxPainter(void) {
   /* TGLBoxPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter));
   G__memfunc_setup("TGLBoxPainter",1251,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter), -1, 0, 1, 1, 4, 0, "u 'TGLBoxPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter), -1, 1, 1, 1, 4, 0, "u 'TGLBoxPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLBoxPainter",1251,G__G__GL_425_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLBoxPainter), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - hist U 'TGLPlotCamera' - 0 - camera "
"U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - stringOption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPlotColor",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPalette",1117,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPaletteAxis",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasSections",1124,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_425_0_20, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLBoxPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_425_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoxPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_425_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLBoxPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_425_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLBoxPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_425_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__GL_425_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoxPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_425_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBoxPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_425_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLBoxPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_425_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLBoxPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLBoxPainter", 1377, G__G__GL_425_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLCameraGuide(void) {
   /* TGLCameraGuide */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide));
   G__memfunc_setup("TGLCameraGuide",1310,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide), -1, 0, 1, 1, 4, 0, "u 'TGLCameraGuide' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide), -1, 1, 1, 1, 4, 0, "u 'TGLCameraGuide' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLCameraGuide",1310,G__G__GL_427_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLCameraGuide), -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - s i 'TGLOverlayElement::ERole' - 0 'kUser' role "
"i 'TGLOverlayElement::EState' - 0 'kActive' state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__G__GL_427_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__G__GL_427_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXY",477,G__G__GL_427_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSize",711,G__G__GL_427_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MouseEnter",1031,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_427_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLCameraGuide::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_427_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCameraGuide::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_427_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLCameraGuide::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_427_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLCameraGuide::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_427_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__GL_427_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCameraGuide::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_427_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCameraGuide::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_427_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCameraGuide::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_427_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCameraGuide::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLCameraGuide", 1436, G__G__GL_427_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLCameraOverlay(void) {
   /* TGLCameraOverlay */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay));
   G__memfunc_setup("TGLCameraOverlay",1554,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay), -1, 0, 1, 1, 4, 0, "u 'TGLCameraOverlay' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay), -1, 1, 1, 1, 4, 0, "u 'TGLCameraOverlay' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RenderPlaneIntersect",2049,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderAxis",1013,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx g - 'Bool_t' 0 - drawGrid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderGrid",998,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBar",885,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLCameraOverlay",1554,G__G__GL_429_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLCameraOverlay), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' showOrtho g - 'Bool_t' 0 'kFALSE' showPersp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RefExternalRefPlane",1901,G__G__GL_429_0_9, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPlane), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseExternalRefPlane",1917,G__G__GL_429_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseExternalRefPlane",2205,G__G__GL_429_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPerspectiveMode",1839,G__G__GL_429_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPerspectiveMode",1851,G__G__GL_429_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLCameraOverlay::EMode' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrthographicMode",1935,G__G__GL_429_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOrthographicMode",1947,G__G__GL_429_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLCameraOverlay::EMode' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowOrthographic",1963,G__G__GL_429_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowOrthographic",1975,G__G__GL_429_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowPerspective",1867,G__G__GL_429_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowPerspective",1879,G__G__GL_429_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrustum",1058,G__G__GL_429_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLCamera' - 1 - cam", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAttAxis",990,G__G__GL_429_0_21, 85, G__get_linked_tagnum(&G__G__GLLN_TAttAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_429_0_22, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLCameraOverlay::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_429_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCameraOverlay::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_429_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLCameraOverlay::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_429_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLCameraOverlay::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_429_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_429_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCameraOverlay::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_429_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCameraOverlay::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_429_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCameraOverlay::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_429_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCameraOverlay::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLCameraOverlay", 1680, G__G__GL_429_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPShapeRef(void) {
   /* TGLPShapeRef */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef));
   G__memfunc_setup("TGLPShapeRef",1093,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef), -1, 0, 1, 1, 4, 0, "u 'TGLPShapeRef' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef), -1, 1, 1, 1, 4, 0, "u 'TGLPShapeRef' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLPShapeRef",1093,G__G__GL_431_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPShapeRef",1093,G__G__GL_431_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeRef), -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPShape",865,G__G__GL_431_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPShape",877,G__G__GL_431_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PShapeModified",1378,G__G__GL_431_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_431_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPShapeRef::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_431_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeRef::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_431_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPShapeRef::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_431_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPShapeRef::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_431_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_431_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_431_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_431_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__GL_431_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeRef::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_431_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPShapeRef::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_431_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeRef::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_431_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPShapeRef::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPShapeRef", 1219, G__G__GL_431_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLManipSet(void) {
   /* TGLManipSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLManipSet));
   G__memfunc_setup("TGLManipSet",1032,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLManipSet), -1, 0, 1, 1, 4, 0, "u 'TGLManipSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLManipSet), -1, 1, 1, 1, 4, 0, "u 'TGLManipSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLManipSet",1032,G__G__GL_433_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLManipSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPShape",877,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseEnter",1031,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentManip",1528,G__G__GL_433_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TGLManip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetManipType",1207,G__G__GL_433_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetManipType",1219,G__G__GL_433_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawBBox",1049,G__G__GL_433_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawBBox",1061,G__G__GL_433_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - bb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_433_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLManipSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_433_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManipSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_433_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLManipSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_433_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLManipSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_433_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__GL_433_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManipSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_433_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLManipSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_433_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLManipSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_433_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLManipSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLManipSet", 1158, G__G__GL_433_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLClip(void) {
   /* TGLClip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClip));
   G__memfunc_setup("Modified",801,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setup",529,G__G__GL_434_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - bbox", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Setup",529,G__G__GL_434_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVector3' - 11 - - u 'TGLVector3' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,G__G__GL_434_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipcLcLEMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMode",689,G__G__GL_434_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLClip::EMode' - 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TimeStamp",916,G__G__GL_434_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncTimeStamp",1198,G__G__GL_434_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__GL_434_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invalidate",1025,G__G__GL_434_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PlaneSet",796,G__G__GL_434_0_12, 121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 1 - set", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__GL_434_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLClip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_434_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_434_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLClip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_434_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLClip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_434_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__GL_434_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_434_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_434_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_434_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClip::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLClip", 749, G__G__GL_434_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLClipPlane(void) {
   /* TGLClipPlane */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane));
   G__memfunc_setup("TGLClipPlane",1119,G__G__GL_436_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipPlane), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - bbox", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVector3' - 11 - point u 'TGLVector3' - 11 - normal", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__GL_436_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLPlane' - 11 - plane", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PlaneSet",796,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 1 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_436_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLClipPlane::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_436_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipPlane::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_436_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLClipPlane::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_436_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLClipPlane::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_436_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__GL_436_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipPlane::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_436_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipPlane::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_436_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipPlane::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_436_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipPlane::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLClipPlane", 1245, G__G__GL_436_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLClipBox(void) {
   /* TGLClipBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipBox));
   G__memfunc_setup("TGLClipBox",920,G__G__GL_437_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - bbox", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLVector3' - 11 - min_point u 'TGLVector3' - 11 - max_point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PlaneSet",796,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 1 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_437_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLClipBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_437_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_437_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLClipBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_437_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLClipBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_437_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__GL_437_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_437_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_437_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_437_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLClipBox", 1046, G__G__GL_437_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLClipSet(void) {
   /* TGLClipSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSet));
   G__memfunc_setup("TGLClipSet",923,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipSet), -1, 0, 1, 1, 4, 0, "u 'TGLClipSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLClipSet), -1, 1, 1, 1, 4, 0, "u 'TGLClipSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLClipSet",923,G__G__GL_438_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MouseEnter",1031,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseStillInside",1645,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsClipping",1010,G__G__GL_438_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentClip",1419,G__G__GL_438_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillPlaneSet",1187,G__G__GL_438_0_11, 121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<TGLPlane,allocator<TGLPlane> >' 'TGLPlaneSet_t' 1 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupClips",1036,G__G__GL_438_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - sceneBBox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupCurrentClip",1660,G__G__GL_438_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - sceneBBox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupCurrentClipIfInvalid",2546,G__G__GL_438_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLBoundingBox' - 11 - sceneBBox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvalidateClips",1532,G__G__GL_438_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvalidateCurrentClip",2156,G__G__GL_438_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipState",1193,G__G__GL_438_0_17, 121, -1, -1, 0, 2, 1, 1, 8, 
"i 'EClipType' - 0 - type D - 'Double_t' 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipState",1205,G__G__GL_438_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'EClipType' - 0 - type D - 'Double_t' 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClipType",1098,G__G__GL_438_0_19, 105, G__get_linked_tagnum(&G__G__GLLN_EClipType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipType",1110,G__G__GL_438_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EClipType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoUpdate",1308,G__G__GL_438_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoUpdate",1320,G__G__GL_438_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - aup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowManip",1206,G__G__GL_438_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowManip",1218,G__G__GL_438_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowClip",1097,G__G__GL_438_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowClip",1109,G__G__GL_438_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - show", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_438_0_27, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLClipSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_438_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_438_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLClipSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_438_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLClipSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_438_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_438_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_438_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_438_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_438_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLClipSet", 1049, G__G__GL_438_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLClipSetSubEditor(void) {
   /* TGLClipSetSubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor));
   G__memfunc_setup("TGLClipSetSubEditor",1836,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor), -1, 0, 1, 1, 4, 0, "u 'TGLClipSetSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor), -1, 1, 1, 1, 4, 0, "u 'TGLClipSetSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLClipSetSubEditor",1836,G__G__GL_441_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipSetSubEditor), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__GL_441_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClipSet' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Changed",682,G__G__GL_441_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("ClipValueChanged",1583,G__G__GL_441_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClipTypeChanged",1492,G__G__GL_441_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateViewerClip",1629,G__G__GL_441_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetViewerClip",1533,G__G__GL_441_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_441_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLClipSetSubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_441_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSetSubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_441_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLClipSetSubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_441_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLClipSetSubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_441_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__GL_441_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSetSubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_441_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipSetSubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_441_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSetSubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_441_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipSetSubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLClipSetSubEditor", 1962, G__G__GL_441_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLClipSetEditor(void) {
   /* TGLClipSetEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor));
   G__memfunc_setup("TGLClipSetEditor",1538,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor), -1, 0, 1, 1, 4, 0, "u 'TGLClipSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor), -1, 1, 1, 1, 4, 0, "u 'TGLClipSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLClipSetEditor",1538,G__G__GL_442_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLClipSetEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '170' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_442_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLClipSetEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_442_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSetEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_442_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLClipSetEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_442_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLClipSetEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_442_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__GL_442_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSetEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_442_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipSetEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_442_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLClipSetEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_442_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLClipSetEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLClipSetEditor", 1664, G__G__GL_442_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLContextIdentity(void) {
   /* TGLContextIdentity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity));
   G__memfunc_setup("TGLContextIdentity",1814,G__G__GL_443_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRef",550,G__G__GL_443_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLContext' - 0 - ctx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__GL_443_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLContext' - 0 - ctx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClientRef",1157,G__G__GL_443_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseClient",1312,G__G__GL_443_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRefCnt",866,G__G__GL_443_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClientRefCnt",1473,G__G__GL_443_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__GL_443_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterDLNameRangeToWipe",2459,G__G__GL_443_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - base i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteGLResources",1697,G__G__GL_443_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrent",1027,G__G__GL_443_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLContextIdentity* (*)())(&TGLContextIdentity::GetCurrent) ), 0);
   G__memfunc_setup("GetDefaultIdentity",1839,G__G__GL_443_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLContextIdentity* (*)())(&TGLContextIdentity::GetDefaultIdentity) ), 0);
   G__memfunc_setup("GetDefaultContextAny",2034,G__G__GL_443_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLContext* (*)())(&TGLContextIdentity::GetDefaultContextAny) ), 0);
   G__memfunc_setup("GetFontManager",1394,G__G__GL_443_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TGLFontManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckDestroy",1224,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_443_0_16, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLContextIdentity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_443_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLContextIdentity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_443_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLContextIdentity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_443_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLContextIdentity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_443_0_20, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_443_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__GL_443_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__GL_443_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__GL_443_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLContextIdentity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_443_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLContextIdentity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_443_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLContextIdentity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_443_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLContextIdentity::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLContextIdentity", 1814, G__G__GL_443_0_28, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 0, 1, 1, 1, 0, "u 'TGLContextIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLContextIdentity", 1940, G__G__GL_443_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_443_0_30, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLContextIdentity), -1, 1, 1, 1, 1, 0, "u 'TGLContextIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLWidget(void) {
   /* TGLWidget */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLWidget));
   G__memfunc_setup("CreateDummy",1120,G__G__GL_446_0_1, 85, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGLWidget* (*)())(&TGLWidget::CreateDummy) ), 0);
   G__memfunc_setup("Create",596,G__G__GL_446_0_2, 85, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 0, 6, 3, 1, 0, 
"U 'TGWindow' - 10 - parent g - 'Bool_t' 0 - selectInput "
"g - 'Bool_t' 0 - shareDefault U 'TGLPaintDevice' - 10 - shareDevice "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height", (char*)NULL, (void*) G__func2void( (TGLWidget* (*)(const TGWindow*, Bool_t, Bool_t, const TGLPaintDevice*, UInt_t, UInt_t))(&TGLWidget::Create) ), 0);
   G__memfunc_setup("Create",596,G__G__GL_446_0_3, 85, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 0, 7, 3, 1, 0, 
"u 'TGLFormat' - 11 - format U 'TGWindow' - 10 - parent "
"g - 'Bool_t' 0 - selectInput g - 'Bool_t' 0 - shareDefault "
"U 'TGLPaintDevice' - 10 - shareDevice h - 'UInt_t' 0 - width "
"h - 'UInt_t' 0 - height", (char*)NULL, (void*) G__func2void( (TGLWidget* (*)(const TGLFormat&, const TGWindow*, Bool_t, Bool_t, const TGLPaintDevice*, UInt_t, UInt_t))(&TGLWidget::Create) ), 0);
   G__memfunc_setup("InitGL",551,G__G__GL_446_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintGL",655,G__G__GL_446_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCurrent",1121,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearCurrent",1226,G__G__GL_446_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwapBuffers",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContext",1029,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TGLContext), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPixelFormat",1419,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFormat",917,G__G__GL_446_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExtractViewport",1595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - vp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEventHandler",1504,G__G__GL_446_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TGEventHandler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEventHandler",1516,G__G__GL_446_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGEventHandler' - 0 - eh", (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 - ev", (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 - ev", (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 - ev", (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 - ev", (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 - ev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleFocusChange",1682,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLWidget",843,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 0, 1, 1, 4, 0, "u 'TGLWidget' - 11 - -", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 1, 1, 1, 4, 0, "u 'TGLWidget' - 11 - -", "Not implemented.", (void*) NULL, 0);
   G__memfunc_setup("TGLWidget",843,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLWidget), -1, 0, 3, 1, 2, 0, 
"k - 'Window_t' 0 - glw U 'TGWindow' - 10 - parent "
"g - 'Bool_t' 0 - selectInput", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateWindow",1228,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("Window_t"), 0, 5, 3, 2, 0, 
"U 'TGWindow' - 10 - parent u 'TGLFormat' - 11 - format "
"h - 'UInt_t' 0 - width h - 'UInt_t' 0 - height "
"u 'pair<void*,void*>' - 1 - innerData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddContext",1006,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGLContext' - 0 - ctx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveContext",1363,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TGLContext' - 0 - ctx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInnerData",1174,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_pairlEvoidmUcOvoidmUgR), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_446_0_30, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLWidget::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_446_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLWidget::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_446_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLWidget::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_446_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLWidget::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_446_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__GL_446_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLWidget::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_446_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLWidget::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_446_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLWidget::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_446_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLWidget::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLWidget", 969, G__G__GL_446_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLCylinder(void) {
   /* TGLCylinder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLCylinder));
   G__memfunc_setup("TGLCylinder",1057,G__G__GL_457_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLCylinder), -1, 0, 1, 1, 1, 0, "u 'TBuffer3DTube' - 11 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DLOffset",759,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "s - 'Short_t' 0 - lod", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportedLODAxes",1590,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QuantizeShapeLOD",1569,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Short_t"), 0, 2, 1, 1, 8, 
"s - 'Short_t' 0 - shapeLOD s - 'Short_t' 0 - combiLOD", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_457_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLCylinder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_457_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCylinder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_457_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLCylinder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_457_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLCylinder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_457_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__GL_457_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCylinder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_457_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCylinder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_457_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLCylinder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_457_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLCylinder::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLCylinder", 1183, G__G__GL_457_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLockable(void) {
   /* TGLLockable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLockable));
   G__memfunc_setup("TGLLockable",1028,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLockable), -1, 0, 1, 1, 4, 0, "u 'TGLLockable' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLockable), -1, 1, 1, 1, 4, 0, "u 'TGLLockable' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLLockable",1028,G__G__GL_458_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLockable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LockIdStr",879,G__G__GL_458_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TakeLock",782,G__G__GL_458_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i 'TGLLockable::ELock' - 0 - lock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseLock",1098,G__G__GL_458_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i 'TGLLockable::ELock' - 0 - lock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLocked",782,G__G__GL_458_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CurrentLock",1132,G__G__GL_458_0_8, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLockablecLcLELock), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDrawOrSelectLock",1780,G__G__GL_458_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LockName",778,G__G__GL_458_0_10, 67, -1, -1, 0, 1, 3, 1, 1, "i 'TGLLockable::ELock' - 0 - lock", (char*)NULL, (void*) G__func2void( (const char* (*)(TGLLockable::ELock))(&TGLLockable::LockName) ), 0);
   G__memfunc_setup("LockValid",889,G__G__GL_458_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "i 'TGLLockable::ELock' - 0 - lock", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TGLLockable::ELock))(&TGLLockable::LockValid) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_458_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLockable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_458_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLockable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_458_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLockable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_458_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLockable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_458_0_16, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_458_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_458_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_458_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__GL_458_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLockable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_458_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLockable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_458_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLockable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_458_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLockable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLLockable", 1154, G__G__GL_458_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSceneInfo(void) {
   /* TGLSceneInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo));
   G__memfunc_setup("TGLSceneInfo",1121,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 1, 1, 4, 0, "u 'TGLSceneInfo' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 1, 1, 1, 4, 0, "u 'TGLSceneInfo' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLSceneInfo",1121,G__G__GL_461_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSceneInfo), -1, 0, 2, 1, 1, 0, 
"U 'TGLViewerBase' - 0 '0' view U 'TGLSceneBase' - 0 '0' scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewer",914,G__G__GL_461_0_4, 85, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefViewer",911,G__G__GL_461_0_5, 117, G__get_linked_tagnum(&G__G__GLLN_TGLViewerBase), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScene",782,G__G__GL_461_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefScene",779,G__G__GL_461_0_7, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSceneBase), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActive",892,G__G__GL_461_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActive",904,G__G__GL_461_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupTransformsAndBBox",2238,G__G__GL_461_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransformedBBox",1808,G__G__GL_461_0_11, 117, G__get_linked_tagnum(&G__G__GLLN_TGLBoundingBox), -1, 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneTrans",1314,G__G__GL_461_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLMatrix' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ViewCheck",889,G__G__GL_461_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewCheck",889,G__G__GL_461_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInFrustum",1129,G__G__GL_461_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InFrustum",941,G__G__GL_461_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInClip",763,G__G__GL_461_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InClip",575,G__G__GL_461_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClipMode",781,G__G__GL_461_0_19, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClipMode",781,G__G__GL_461_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShouldClip",1015,G__G__GL_461_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,G__G__GL_461_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FrustumPlanes",1369,G__G__GL_461_0_23, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR), G__defined_typename("vector<TGLPlane>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClipPlanes",1003,G__G__GL_461_0_24, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR), G__defined_typename("vector<TGLPlane>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LOD",223,G__G__GL_461_0_25, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLOD",523,G__G__GL_461_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - lod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Style",529,G__G__GL_461_0_27, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStyle",829,G__G__GL_461_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WFLineW",636,G__G__GL_461_0_29, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWFLineW",936,G__G__GL_461_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OLLineW",634,G__G__GL_461_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOLLineW",934,G__G__GL_461_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clip",392,G__G__GL_461_0_33, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClip",692,G__G__GL_461_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastLOD",627,G__G__GL_461_0_35, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastLOD",927,G__G__GL_461_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - ld", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastStyle",933,G__G__GL_461_0_37, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastStyle",1233,G__G__GL_461_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastWFLineW",1040,G__G__GL_461_0_39, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastWFLineW",1340,G__G__GL_461_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastOLLineW",1038,G__G__GL_461_0_41, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastOLLineW",1338,G__G__GL_461_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastClip",796,G__G__GL_461_0_43, 85, G__get_linked_tagnum(&G__G__GLLN_TGLClip), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastClip",1096,G__G__GL_461_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLClip' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastCamera",989,G__G__GL_461_0_45, 85, G__get_linked_tagnum(&G__G__GLLN_TGLCamera), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastCamera",1289,G__G__GL_461_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLCamera' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneStamp",1011,G__G__GL_461_0_47, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSceneStamp",1311,G__G__GL_461_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - ts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetSceneStamp",1526,G__G__GL_461_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClipStamp",909,G__G__GL_461_0_50, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClipStamp",1209,G__G__GL_461_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - ts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetClipStamp",1424,G__G__GL_461_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CameraStamp",1102,G__G__GL_461_0_53, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCameraStamp",1402,G__G__GL_461_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - ts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetCameraStamp",1617,G__G__GL_461_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasUpdateTimeouted",1839,G__G__GL_461_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateTimeouted",1555,G__G__GL_461_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetUpdateTimeouted",2070,G__G__GL_461_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_461_0_59, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSceneInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_461_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSceneInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_461_0_61, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSceneInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_461_0_62, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSceneInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_461_0_63, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_461_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_461_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_461_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_461_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSceneInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_461_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSceneInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_461_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSceneInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_461_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSceneInfo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSceneInfo", 1247, G__G__GL_461_0_71, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLStopwatch(void) {
   /* TGLStopwatch */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch));
   G__memfunc_setup("GetClock",780,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLStopwatch",1188,G__G__GL_472_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Start",526,G__G__GL_472_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lap",285,G__G__GL_472_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("End",279,G__G__GL_472_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastRun",713,G__G__GL_472_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_472_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLStopwatch::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_472_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLStopwatch::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_472_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLStopwatch::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_472_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLStopwatch::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_472_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_472_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_472_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_472_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__GL_472_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLStopwatch::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_472_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLStopwatch::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_472_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLStopwatch::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_472_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLStopwatch::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLStopwatch", 1188, G__G__GL_472_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch), -1, 0, 1, 1, 1, 0, "u 'TGLStopwatch' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLStopwatch", 1314, G__G__GL_472_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_472_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLStopwatch), -1, 1, 1, 1, 1, 0, "u 'TGLStopwatch' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSelectBuffer(void) {
   /* TGLSelectBuffer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer));
   G__memfunc_setup("TGLSelectBuffer",1441,G__G__GL_473_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufSize",984,G__G__GL_473_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuf",573,G__G__GL_473_0_3, 72, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNRecords",1088,G__G__GL_473_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanGrow",689,G__G__GL_473_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Grow",415,G__G__GL_473_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessResult",1374,G__G__GL_473_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - glResult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RawRecord",905,G__G__GL_473_0_8, 72, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectRecord",1215,G__G__GL_473_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLSelectRecordBase' - 1 - rec i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_473_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSelectBuffer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_473_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectBuffer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_473_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSelectBuffer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_473_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSelectBuffer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_473_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_473_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_473_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_473_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__GL_473_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectBuffer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_473_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectBuffer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_473_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectBuffer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_473_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectBuffer::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLSelectBuffer", 1441, G__G__GL_473_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer), -1, 0, 1, 1, 1, 0, "u 'TGLSelectBuffer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLSelectBuffer", 1567, G__G__GL_473_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_473_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLSelectBuffer), -1, 1, 1, 1, 1, 0, "u 'TGLSelectBuffer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSelectRecordBase(void) {
   /* TGLSelectRecordBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase));
   G__memfunc_setup("CopyItems",925,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "H - 'UInt_t' 0 - items", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSelectRecordBase",1825,G__G__GL_482_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSelectRecordBase",1825,G__G__GL_482_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase), -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSelectRecordBase",1825,G__G__GL_482_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase), -1, 0, 1, 1, 1, 0, "u 'TGLSelectRecordBase' - 11 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__GL_482_0_5, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSelectRecordBase), -1, 1, 1, 1, 1, 0, "u 'TGLSelectRecordBase' - 11 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRawOnly",1016,G__G__GL_482_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__GL_482_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "H - 'UInt_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__GL_482_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,G__G__GL_482_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetItems",802,G__G__GL_482_0_10, 72, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetItem",687,G__G__GL_482_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinZ",670,G__G__GL_482_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxZ",672,G__G__GL_482_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrItem",1099,G__G__GL_482_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNLeft",761,G__G__GL_482_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextPos",721,G__G__GL_482_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrevPos",719,G__G__GL_482_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetPos",821,G__G__GL_482_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_482_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSelectRecordBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_482_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectRecordBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_482_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSelectRecordBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_482_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSelectRecordBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_482_0_23, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_482_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_482_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_482_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__GL_482_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectRecordBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_482_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectRecordBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_482_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSelectRecordBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_482_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSelectRecordBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSelectRecordBase", 1951, G__G__GL_482_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPerspectiveCamera(void) {
   /* TGLPerspectiveCamera */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera));
   G__memfunc_setup("TGLPerspectiveCamera",1978,G__G__GL_489_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPerspectiveCamera), -1, 0, 2, 1, 1, 0, 
"u 'TGLVector3' - 11 - hAxis u 'TGLVector3' - 11 - vAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsPerspective",1350,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFOV",523,G__G__GL_489_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLBoundingBox' - 11 - box g - 'Bool_t' 0 'kTRUE' reset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - delta g - 'Bool_t' 0 - mod1 "
"g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Truck",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TGLBoundingBox' - 11 - box U 'TGLRect' - 10 '0' pickRect", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Configure",930,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - fov d - 'Double_t' 0 - dolly "
"D - 'Double_t' 0 - center d - 'Double_t' 0 - hRotate "
"d - 'Double_t' 0 - vRotate", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_489_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPerspectiveCamera::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_489_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPerspectiveCamera::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_489_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPerspectiveCamera::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_489_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPerspectiveCamera::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_489_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__GL_489_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPerspectiveCamera::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_489_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPerspectiveCamera::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_489_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPerspectiveCamera::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_489_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPerspectiveCamera::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPerspectiveCamera", 2104, G__G__GL_489_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLOrthoCamera(void) {
   /* TGLOrthoCamera */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera));
   G__memfunc_setup("TGLOrthoCamera",1340,G__G__GL_490_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera), -1, 0, 3, 1, 1, 0, 
"i 'TGLOrthoCamera::EType' - 0 - type u 'TGLVector3' - 11 - hAxis "
"u 'TGLVector3' - 11 - vAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOrthographic",1446,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLBoundingBox' - 11 - box g - 'Bool_t' 0 'kTRUE' reset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dolly",516,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - delta g - 'Bool_t' 0 - mod1 "
"g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - delta g - 'Bool_t' 0 - mod1 "
"g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Truck",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rotate",623,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TGLBoundingBox' - 11 - sceneBox U 'TGLRect' - 10 '0' pickRect", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Configure",930,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - zoom d - 'Double_t' 0 - dolly "
"D - 'Double_t' 0 - center d - 'Double_t' 0 - hRotate "
"d - 'Double_t' 0 - vRotate", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEnableRotate",1506,G__G__GL_490_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnableRotate",1494,G__G__GL_490_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZoomMin",1001,G__G__GL_490_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZoomMax",1003,G__G__GL_490_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZoomMin",1013,G__G__GL_490_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZoomMax",1015,G__G__GL_490_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZoomMinMax",1307,G__G__GL_490_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDollyToZoom",1432,G__G__GL_490_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDollyToZoom",1420,G__G__GL_490_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_490_0_20, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLOrthoCamera::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_490_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOrthoCamera::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_490_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLOrthoCamera::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_490_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOrthoCamera::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_490_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__GL_490_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOrthoCamera::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_490_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOrthoCamera::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_490_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOrthoCamera::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_490_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOrthoCamera::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLOrthoCamera", 1466, G__G__GL_490_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLViewerEditor(void) {
   /* TGLViewerEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor));
   G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLViewerEditor",1472,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor), -1, 0, 1, 1, 4, 0, "u 'TGLViewerEditor' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor), -1, 1, 1, 1, 4, 0, "u 'TGLViewerEditor' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateStyleTab",1404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateGuidesTab",1484,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateClippingTab",1697,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateExtrasTab",1506,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateReferencePosState",2341,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLViewerEditor",1472,G__G__GL_502_0_9, 105, G__get_linked_tagnum(&G__G__GLLN_TGLViewerEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewerRedraw",1239,G__G__GL_502_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGuides",909,G__G__GL_502_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoClearColor",1177,G__G__GL_502_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoIgnoreSizesOnUpdate",2117,G__G__GL_502_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoResetCamerasOnUpdate",2194,G__G__GL_502_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUpdateScene",1284,G__G__GL_502_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCameraHome",1157,G__G__GL_502_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateMaxDrawTimes",1817,G__G__GL_502_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdatePointLineStuff",2045,G__G__GL_502_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCameraCenterExt",1678,G__G__GL_502_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCaptureCenter",1512,G__G__GL_502_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAnnotation",1230,G__G__GL_502_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDrawCameraCenter",1771,G__G__GL_502_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateCameraCenter",1805,G__G__GL_502_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateViewerAxes",1638,G__G__GL_502_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateViewerReference",2148,G__G__GL_502_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCameraOverlay",1502,G__G__GL_502_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateRotator",1358,G__G__GL_502_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotatorStart",1452,G__G__GL_502_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRotatorStop",1348,G__G__GL_502_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateStereo",1237,G__G__GL_502_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DetachFromPad",1266,G__G__GL_502_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeLabeledNEntry",1671,G__G__GL_502_0_33, 85, G__get_linked_tagnum(&G__G__GLLN_TGNumberEntry), -1, 0, 5, 3, 1, 0, 
"U 'TGCompositeFrame' - 0 - p C - - 10 - name "
"i - 'Int_t' 0 - labelw i - 'Int_t' 0 '7' nd "
"i - 'Int_t' 0 '5' s", (char*)NULL, (void*) G__func2void( (TGNumberEntry* (*)(TGCompositeFrame*, const char*, Int_t, Int_t, Int_t))(&TGLViewerEditor::MakeLabeledNEntry) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_502_0_34, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLViewerEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_502_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewerEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_502_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLViewerEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_502_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLViewerEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_502_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__GL_502_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewerEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_502_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLViewerEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_502_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLViewerEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_502_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLViewerEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLViewerEditor", 1598, G__G__GL_502_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLightSet(void) {
   /* TGLLightSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSet));
   G__memfunc_setup("TGLLightSet",1035,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLightSet), -1, 0, 1, 1, 4, 0, "u 'TGLLightSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLightSet), -1, 1, 1, 1, 4, 0, "u 'TGLLightSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLLightSet",1035,G__G__GL_503_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLightSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleLight",1114,G__G__GL_503_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGLLightSet::ELight' - 0 - light", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLight",804,G__G__GL_503_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'TGLLightSet::ELight' - 0 - light g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLightState",1305,G__G__GL_503_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseSpecular",1420,G__G__GL_503_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseSpecular",1432,G__G__GL_503_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrontPower",1334,G__G__GL_503_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSidePower",1202,G__G__GL_503_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpecularPower",1644,G__G__GL_503_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrontPower",1346,G__G__GL_503_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSidePower",1214,G__G__GL_503_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSpecularPower",1656,G__G__GL_503_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StdSetupLights",1447,G__G__GL_503_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TGLBoundingBox' - 11 - bbox u 'TGLCamera' - 11 - camera "
"g - 'Bool_t' 0 'kFALSE' debug", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_503_0_16, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLightSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_503_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_503_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLightSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_503_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLightSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_503_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__GL_503_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_503_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLightSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_503_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_503_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLightSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLLightSet", 1161, G__G__GL_503_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPShapeObj(void) {
   /* TGLPShapeObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj));
   G__memfunc_setup("TGLPShapeObj",1091,G__G__GL_504_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPShapeObj",1091,G__G__GL_504_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj), -1, 0, 2, 1, 1, 0, 
"U 'TGLPhysicalShape' - 0 - sh U 'TGLViewer' - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLPShapeObj",1091,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj), -1, 0, 1, 1, 4, 0, "u 'TGLPShapeObj' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObj), -1, 1, 1, 1, 4, 0, "u 'TGLPShapeObj' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_504_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPShapeObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_504_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_504_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPShapeObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_504_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPShapeObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_504_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__GL_504_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_504_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPShapeObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_504_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_504_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPShapeObj::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPShapeObj", 1217, G__G__GL_504_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLOutput(void) {
   /* TGLOutput */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOutput));
   G__memfunc_setup("Capture",724,G__G__GL_505_0_1, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"u 'TGLViewer' - 1 - viewer i 'TGLOutput::EFormat' - 0 - format "
"C - - 10 '0' filePath", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TGLViewer&, TGLOutput::EFormat, const char*))(&TGLOutput::Capture) ), 0);
   G__memfunc_setup("StartEmbeddedPS",1467,G__G__GL_505_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", "gl to ps in pad, \"embedded\" does not mean eps format here", (void*) G__func2void( (void (*)())(&TGLOutput::StartEmbeddedPS) ), 0);
   G__memfunc_setup("CloseEmbeddedPS",1443,G__G__GL_505_0_3, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOutput::CloseEmbeddedPS) ), 0);
   G__memfunc_setup("Capture",724,G__G__GL_505_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "u 'TGLViewer' - 1 - viewer", (char*)NULL, (void*) G__func2void( (void (*)(TGLViewer&))(&TGLOutput::Capture) ), 0);
   G__memfunc_setup("CapturePostscript",1807,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 4, 0, 
"u 'TGLViewer' - 1 - viewer i 'TGLOutput::EFormat' - 0 - format "
"C - - 10 - filePath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_505_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLOutput::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_505_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOutput::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_505_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLOutput::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_505_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOutput::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_505_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_505_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_505_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_505_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__GL_505_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOutput::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_505_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOutput::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_505_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOutput::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_505_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOutput::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TGLOutput", 888, G__G__GL_505_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLOutput), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TGLOutput", 888, G__G__GL_505_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLOutput), -1, 0, 1, 1, 1, 0, "u 'TGLOutput' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLOutput", 1014, G__G__GL_505_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__GL_505_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__GLLN_TGLOutput), -1, 1, 1, 1, 1, 0, "u 'TGLOutput' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLEventHandler(void) {
   /* TGLEventHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler));
   G__memfunc_setup("Rotate",623,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GrabMouse",901,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnGrabMouse",1096,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectForClicked",1590,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectForMouseOver",1836,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ControlValue",1246,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLEventHandler",1447,G__G__GL_506_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLEventHandler), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 0 - w U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleEvent",1102,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleExpose",1216,G__G__GL_506_0_10, 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("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("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("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("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("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("StartMouseTimer",1560,G__G__GL_506_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopMouseTimer",1456,G__G__GL_506_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearMouseOver",1420,G__G__GL_506_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Repaint",723,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopupContextMenu",1678,G__G__GL_506_0_23, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGLPhysicalShape' - 0 - pshp U 'Event_t' - 0 - event "
"i - 'Int_t' 0 - gx i - 'Int_t' 0 - gy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TriggerTooltip",1471,G__G__GL_506_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveTooltip",1369,G__G__GL_506_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMouseOverSelectDelay",2336,G__G__GL_506_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMouseOverTooltipDelay",2475,G__G__GL_506_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTooltipPixelTolerance",2474,G__G__GL_506_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTooltipPixelTolerance",2486,G__G__GL_506_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSecSelType",1281,G__G__GL_506_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSecSelType",1293,G__G__GL_506_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDoInternalSelection",2230,G__G__GL_506_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDoInternalSelection",2242,G__G__GL_506_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_506_0_34, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLEventHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_506_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLEventHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_506_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLEventHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_506_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLEventHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_506_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__GL_506_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLEventHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_506_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLEventHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_506_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLEventHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_506_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLEventHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLEventHandler", 1573, G__G__GL_506_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLFaderHelper(void) {
   /* TGLFaderHelper */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper));
   G__memfunc_setup("TGLFaderHelper",1321,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper), -1, 0, 1, 1, 4, 0, "u 'TGLFaderHelper' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper), -1, 1, 1, 1, 4, 0, "u 'TGLFaderHelper' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLFaderHelper",1321,G__G__GL_511_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFaderHelper",1321,G__G__GL_511_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFaderHelper), -1, 0, 4, 1, 1, 0, 
"U 'TGLViewer' - 0 - v f - 'Float_t' 0 - fade "
"f - 'Float_t' 0 - time i - 'Int_t' 0 - steps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeFadeStep",1162,G__G__GL_511_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_511_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLFaderHelper::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_511_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFaderHelper::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_511_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLFaderHelper::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_511_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLFaderHelper::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_511_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_511_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_511_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_511_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__GL_511_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFaderHelper::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_511_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFaderHelper::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_511_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFaderHelper::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_511_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFaderHelper::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLFaderHelper", 1447, G__G__GL_511_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLEmbeddedViewer(void) {
   /* TGLEmbeddedViewer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGWindow' - 10 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateFrames",1202,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLEmbeddedViewer",1635,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer), -1, 0, 1, 1, 4, 0, "u 'TGLEmbeddedViewer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer), -1, 1, 1, 1, 4, 0, "u 'TGLEmbeddedViewer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLEmbeddedViewer",1635,G__G__GL_513_0_5, 105, G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 - parent U 'TVirtualPad' - 0 '0' pad "
"i - 'Int_t' 0 '2' border", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLEmbeddedViewer",1635,G__G__GL_513_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLEmbeddedViewer), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - parent U 'TVirtualPad' - 0 - pad "
"U 'TGedEditor' - 0 - ged i - 'Int_t' 0 '2' border", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateGLWidget",1355,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyGLWidget",1505,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFrame",779,G__G__GL_513_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrthoXOYCamera",1653,G__G__GL_513_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrthoXOZCamera",1654,G__G__GL_513_0_12, 85, G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrthoZOYCamera",1655,G__G__GL_513_0_13, 85, G__get_linked_tagnum(&G__G__GLLN_TGLOrthoCamera), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_513_0_14, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLEmbeddedViewer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_513_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLEmbeddedViewer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_513_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLEmbeddedViewer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_513_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLEmbeddedViewer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_513_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__GL_513_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLEmbeddedViewer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_513_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLEmbeddedViewer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_513_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLEmbeddedViewer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_513_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLEmbeddedViewer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLEmbeddedViewer", 1761, G__G__GL_513_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLFaceSet(void) {
   /* TGLFaceSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet));
   G__memfunc_setup("TGLFaceSet",898,G__G__GL_516_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFaceSet), -1, 0, 1, 1, 1, 0, "u 'TBuffer3D' - 11 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFromMesh",1101,G__G__GL_516_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RootCsg::TBaseMesh' - 10 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateNormals",1642,G__G__GL_516_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnforceTriangles",1643,G__G__GL_516_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertices",1125,G__G__GL_516_0_6, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormals",1020,G__G__GL_516_0_7, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolyDesc",1091,G__G__GL_516_0_8, 117, G__get_linked_tagnum(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbPols",878,G__G__GL_516_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnforceTriangles",1931,G__G__GL_516_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TGLFaceSet::GetEnforceTriangles) ), 0);
   G__memfunc_setup("SetEnforceTriangles",1943,G__G__GL_516_0_11, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - e", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TGLFaceSet::SetEnforceTriangles) ), 0);
   G__memfunc_setup("GLDrawPolys",1080,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckPoints",1115,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 8, 
"I - 'Int_t' 10 - source I - 'Int_t' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eq",182,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 4, 0, 
"D - 'Double_t' 10 - p1 D - 'Double_t' 10 - p2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_516_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLFaceSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_516_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFaceSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_516_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLFaceSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_516_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLFaceSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_516_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__GL_516_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFaceSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_516_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFaceSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_516_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFaceSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_516_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFaceSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLFaceSet", 1024, G__G__GL_516_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLFBO(void) {
   /* TGLFBO */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLFBO));
   G__memfunc_setup("TGLFBO",446,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFBO), -1, 0, 1, 1, 4, 0, "u 'TGLFBO' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLFBO), -1, 1, 1, 1, 4, 0, "u 'TGLFBO' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitStandard",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitMultiSample",1537,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateAndAttachRenderBuffer",2678,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - format i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateAndAttachColorTexture",2732,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLFBO",446,G__G__GL_517_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLFBO), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__GL_517_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - w i - - 0 - h "
"i - - 0 '0' ms_samples", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__GL_517_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Bind",381,G__G__GL_517_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unbind",608,G__G__GL_517_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BindTexture",1134,G__G__GL_517_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnbindTexture",1361,G__G__GL_517_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAsReadBuffer",1462,G__G__GL_517_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_517_0_15, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLFBO::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_517_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFBO::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_517_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLFBO::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_517_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLFBO::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__GL_517_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__GL_517_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__GL_517_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__GL_517_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__GL_517_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFBO::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_517_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFBO::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_517_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLFBO::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_517_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLFBO::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLFBO", 572, G__G__GL_517_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPadPainter(void) {
   /* TGLPadPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter));
   G__memfunc_setup("TGLPadPainter",1231,G__G__GL_518_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineColor",1191,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineStyle",1209,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineWidth",1192,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Width_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - lcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - lstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFillColor",1190,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFillStyle",1208,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsTransparent",1358,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillColor",1202,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - fcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillStyle",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - fstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOpacity",1029,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - percent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextAlign",1200,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextAngle",1196,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextColor",1220,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextFont",1116,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Font_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextSize",1120,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextMagnitude",1635,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextAlign",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - align", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextAngle",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - tangle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - tcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextFont",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Font_t' 0 - tfont", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextSize",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - tsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextSizePixels",1761,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npixels", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateDrawable",1398,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearDrawable",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyDrawable",1213,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyDrawable",1548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectDrawable",1410,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - device", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitPainter",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvalidateCS",1175,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LockPainter",1116,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLine",790,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLineNDC",1003,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - u1 d - 'Double_t' 0 - v1 "
"d - 'Double_t' 0 - u2 d - 'Double_t' 0 - v2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBox",695,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"i 'TVirtualPadPainter::EBoxMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFillArea",1166,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawFillArea",1166,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyLine",1210,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyLine",1210,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyLineNDC",1423,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - u "
"D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyMarker",1428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyMarker",1428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawText",819,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text i 'TVirtualPadPainter::ETextMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawTextNDC",1032,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - text i 'TVirtualPadPainter::ETextMode' - 0 - mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveImage",882,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"U 'TVirtualPad' - 0 - pad C - - 10 - fileName "
"i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveProjectionMatrix",2081,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreProjectionMatrix",2422,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveModelviewMatrix",1968,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreModelviewMatrix",2309,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveViewport",1263,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreViewport",1604,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPolyMarker",1428,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLPadPainter",1231,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter), -1, 0, 1, 1, 4, 0, "u 'TGLPadPainter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLPadPainter), -1, 1, 1, 1, 4, 0, "u 'TGLPadPainter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_518_0_56, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPadPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_518_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPadPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_518_0_58, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPadPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_518_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPadPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_518_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_518_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPadPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_518_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPadPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_518_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPadPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_518_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPadPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPadPainter", 1357, G__G__GL_518_0_68, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLH2PolyPainter(void) {
   /* TGLH2PolyPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter));
   G__memfunc_setup("TGLH2PolyPainter",1496,G__G__GL_542_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLH2PolyPainter), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - hist U 'TGLPlotCamera' - 0 - camera "
"U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - stringOption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawExtrusion",1375,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawExtrusion",1375,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 8, 
"U 'TGraph' - 10 - polygon d - 'Double_t' 0 - zMin "
"d - 'Double_t' 0 - zMax i - 'Int_t' 0 - nBin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawExtrusion",1375,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 8, 
"U 'TMultiGraph' - 10 - polygon d - 'Double_t' 0 - zMin "
"d - 'Double_t' 0 - zMax i - 'Int_t' 0 - nBin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCaps",789,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCap",674,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'list<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> >,allocator<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> > > >::iterator' 'TGLH2PolyPainter::CIter_t' 0 - cap i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CacheGeometry",1312,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildTesselation",1659,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 0, 
"u 'Rgl::Pad::Tesselator' - 1 - tess U 'TGraph' - 10 - g "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildTesselation",1659,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 0, 
"u 'Rgl::Pad::Tesselator' - 1 - tess U 'TMultiGraph' - 10 - mg "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateGeometry",1455,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinColor",1092,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPalette",1117,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPaletteAxis",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillTemporaryPolygon",2098,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 8, 
"D - 'Double_t' 10 - xs D - 'Double_t' 10 - ys "
"d - 'Double_t' 0 - z i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePolygonCCW",1347,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClampZ",583,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 1 - zVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_542_0_29, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLH2PolyPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_542_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLH2PolyPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_542_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLH2PolyPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_542_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLH2PolyPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_542_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_542_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLH2PolyPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_542_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLH2PolyPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_542_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLH2PolyPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_542_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLH2PolyPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLH2PolyPainter", 1622, G__G__GL_542_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLegoPainter(void) {
   /* TGLLegoPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter));
   G__memfunc_setup("TGLLegoPainter",1345,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter), -1, 0, 1, 1, 4, 0, "u 'TGLLegoPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter), -1, 1, 1, 1, 4, 0, "u 'TGLLegoPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLLegoPainter",1345,G__G__GL_547_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLegoPainter), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - hist U 'TGLPlotCamera' - 0 - camera "
"U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - stringOption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometryCartesian",2170,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometryPolar",1758,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometryCylindrical",2382,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometrySpherical",2171,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLegoCartesian",1711,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawLegoPolar",1299,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawLegoCylindrical",1923,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawLegoSpherical",1712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLegoColor",1202,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClampZ",583,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 1 - zVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreparePalette",1438,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPalette",1117,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPaletteAxis",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_547_0_29, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLegoPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_547_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLegoPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_547_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLegoPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_547_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLegoPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_547_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_547_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLegoPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_547_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLegoPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_547_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLegoPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_547_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLegoPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLLegoPainter", 1471, G__G__GL_547_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLightSetSubEditor(void) {
   /* TGLLightSetSubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor));
   G__memfunc_setup("TGLLightSetSubEditor",1948,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor), -1, 0, 1, 1, 4, 0, "u 'TGLLightSetSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor), -1, 1, 1, 1, 4, 0, "u 'TGLLightSetSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeLampButton",1412,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TGButton), -1, 0, 3, 1, 2, 0, 
"C - - 10 - name i - 'Int_t' 0 - wid "
"U 'TGCompositeFrame' - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLLightSetSubEditor",1948,G__G__GL_553_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLightSetSubEditor), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__GL_553_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLLightSet' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Changed",682,G__G__GL_553_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("DoButton",815,G__G__GL_553_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_553_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLightSetSubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_553_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSetSubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_553_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLightSetSubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_553_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLightSetSubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_553_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__GL_553_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSetSubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_553_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLightSetSubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_553_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSetSubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_553_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLightSetSubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLLightSetSubEditor", 2074, G__G__GL_553_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLLightSetEditor(void) {
   /* TGLLightSetEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor));
   G__memfunc_setup("TGLLightSetEditor",1650,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor), -1, 0, 1, 1, 4, 0, "u 'TGLLightSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor), -1, 1, 1, 1, 4, 0, "u 'TGLLightSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLLightSetEditor",1650,G__G__GL_554_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLLightSetEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '170' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_554_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLLightSetEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_554_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSetEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_554_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLLightSetEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_554_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLLightSetEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_554_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__GL_554_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSetEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_554_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLightSetEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_554_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLLightSetEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_554_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLLightSetEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLLightSetEditor", 1776, G__G__GL_554_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLOverlayButton(void) {
   /* TGLOverlayButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton));
   G__memfunc_setup("TGLOverlayButton",1605,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton), -1, 0, 1, 1, 4, 0, "u 'TGLOverlayButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton), -1, 1, 1, 1, 4, 0, "u 'TGLOverlayButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLOverlayButton",1605,G__G__GL_558_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLOverlayButton), -1, 0, 6, 1, 1, 0, 
"U 'TGLViewerBase' - 0 - parent C - - 10 - text "
"f - 'Float_t' 0 - posx f - 'Float_t' 0 - posy "
"f - 'Float_t' 0 - width f - 'Float_t' 0 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MouseEnter",1031,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetState",1028,G__G__GL_558_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,G__G__GL_558_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBackColor",1168,G__G__GL_558_0_10, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextColor",1220,G__G__GL_558_0_11, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,G__G__GL_558_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPosition",1153,G__G__GL_558_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSize",711,G__G__GL_558_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - w f - 'Float_t' 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlphaValues",1410,G__G__GL_558_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - norm f - 'Float_t' 0 - high", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBackColor",1180,G__G__GL_558_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTextColor",1232,G__G__GL_558_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clicked",687,G__G__GL_558_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLViewerBase' - 0 - viewer", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_558_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLOverlayButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_558_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_558_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLOverlayButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_558_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLOverlayButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_558_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__GL_558_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_558_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOverlayButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_558_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLOverlayButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_558_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLOverlayButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLOverlayButton", 1731, G__G__GL_558_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLParametricEquationGL(void) {
   /* TGLParametricEquationGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL));
   G__memfunc_setup("TGLParametricEquationGL",2248,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL), -1, 0, 1, 1, 4, 0, "u 'TGLParametricEquationGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL), -1, 1, 1, 1, 4, 0, "u 'TGLParametricEquationGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGLParametricEquationGL",2248,G__G__GL_562_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricEquationGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeepDuringSmartRefresh",2244,(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__GL_562_0_8, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLParametricEquationGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_562_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricEquationGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_562_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLParametricEquationGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_562_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLParametricEquationGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_562_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__GL_562_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricEquationGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_562_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLParametricEquationGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_562_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricEquationGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_562_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLParametricEquationGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLParametricEquationGL", 2374, G__G__GL_562_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLParametricPlot(void) {
   /* TGLParametricPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot));
   G__memfunc_setup("TGLParametricPlot",1678,G__G__GL_578_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot), -1, 0, 2, 1, 1, 0, 
"U 'TGLParametricEquation' - 0 - equation U 'TGLPlotCamera' - 0 - camera", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitColors",1030,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSurfaceColor",1524,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLParametricPlot",1678,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot), -1, 0, 1, 1, 4, 0, "u 'TGLParametricPlot' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLParametricPlot), -1, 1, 1, 1, 4, 0, "u 'TGLParametricPlot' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_578_0_18, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLParametricPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_578_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_578_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLParametricPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_578_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLParametricPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_578_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__GL_578_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_578_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLParametricPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_578_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLParametricPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_578_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLParametricPlot::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLParametricPlot", 1804, G__G__GL_578_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPolyLine(void) {
   /* TGLPolyLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPolyLine));
   G__memfunc_setup("TGLPolyLine",1043,G__G__GL_586_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPolyLine), -1, 0, 1, 1, 1, 0, "u 'TBuffer3D' - 11 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_586_0_3, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPolyLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_586_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPolyLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_586_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPolyLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_586_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPolyLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_586_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__GL_586_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPolyLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_586_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPolyLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_586_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPolyLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_586_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPolyLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPolyLine", 1169, G__G__GL_586_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPolyMarker(void) {
   /* TGLPolyMarker */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPolyMarker));
   G__memfunc_setup("TGLPolyMarker",1261,G__G__GL_587_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPolyMarker), -1, 0, 1, 1, 1, 0, "u 'TBuffer3D' - 11 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreSizeForOfInterest",2345,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawStars",923,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_587_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPolyMarker::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_587_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPolyMarker::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_587_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPolyMarker::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_587_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPolyMarker::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_587_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__GL_587_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPolyMarker::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_587_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPolyMarker::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_587_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPolyMarker::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_587_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPolyMarker::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPolyMarker", 1387, G__G__GL_587_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLPShapeObjEditor(void) {
   /* TGLPShapeObjEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor));
   G__memfunc_setup("CreateGeoControls",1731,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateColorControls",1959,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGLPShapeObjEditor",1706,G__G__GL_591_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLPShapeObjEditor), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
"i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
"k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPShape",877,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PShapeModified",1378,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCenter",909,G__G__GL_591_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - center", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScale",788,G__G__GL_591_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoGeoButton",1098,G__G__GL_591_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectData",1265,G__G__GL_591_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - shift D - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GeoValueSet",1092,G__G__GL_591_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - unusedVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateColorRadioButtons",2353,G__G__GL_591_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateColorSliders",1833,G__G__GL_591_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColorSlidersPos",1843,G__G__GL_591_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSphere",1013,G__G__GL_591_0_16, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRGBA",584,G__G__GL_591_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRGBA",572,G__G__GL_591_0_18, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoColorSlider",1301,G__G__GL_591_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoColorButton",1326,G__G__GL_591_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_591_0_21, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLPShapeObjEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_591_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeObjEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_591_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLPShapeObjEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_591_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLPShapeObjEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_591_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__GL_591_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeObjEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_591_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPShapeObjEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_591_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLPShapeObjEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_591_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLPShapeObjEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLPShapeObjEditor", 1832, G__G__GL_591_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLRotateManip(void) {
   /* TGLRotateManip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip));
   G__memfunc_setup("DrawAxisRing",1203,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 8, 
"u 'TGLVertex3' - 11 - origin u 'TGLVector3' - 11 - axis "
"d - 'Double_t' 0 - radius F - 'Float_t' 0 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateAngleDelta",1887,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'TPoint' - 11 - mouse u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateRingLine",1702,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLLine3), -1, 0, 2, 1, 4, 8, 
"u 'TPoint' - 11 - mouse u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Angle",487,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 2, 0, 
"u 'TGLVector3' - 11 - v1 u 'TGLVector3' - 11 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Angle",487,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 3, 2, 0, 
"u 'TGLVector3' - 11 - v1 u 'TGLVector3' - 11 - v2 "
"u 'TGLVector3' - 11 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLRotateManip",1355,G__G__GL_593_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLRotateManip",1355,G__G__GL_593_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip), -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_593_0_11, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLRotateManip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_593_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRotateManip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_593_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLRotateManip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_593_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLRotateManip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_593_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__GL_593_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRotateManip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_593_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLRotateManip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_593_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLRotateManip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_593_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLRotateManip::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLRotateManip", 1355, G__G__GL_593_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLRotateManip), -1, 0, 1, 1, 1, 0, "u 'TGLRotateManip' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLRotateManip", 1481, G__G__GL_593_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSAViewer(void) {
   /* TGLSAViewer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer));
   G__memfunc_setup("ResetMenuHidingTimer",2028,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - show_menu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMenus",1116,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateFrames",1202,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSAViewer",1005,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer), -1, 0, 1, 1, 4, 0, "u 'TGLSAViewer' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer), -1, 1, 1, 1, 4, 0, "u 'TGLSAViewer' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSAViewer",1005,G__G__GL_594_0_6, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer), -1, 0, 2, 1, 1, 0, 
"U 'TVirtualPad' - 0 - pad U 'TGLFormat' - 0 '0' format", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSAViewer",1005,G__G__GL_594_0_7, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSAViewer), -1, 0, 4, 1, 1, 0, 
"U 'TGWindow' - 10 - parent U 'TVirtualPad' - 0 - pad "
"U 'TGedEditor' - 0 '0' ged U 'TGLFormat' - 0 '0' format", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateGLWidget",1355,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyGLWidget",1505,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectionChanged",1616,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__GL_594_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,G__G__GL_594_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteMenuBar",1277,G__G__GL_594_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableCloseMenuEntries",2329,G__G__GL_594_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableMenuBarHiding",1860,G__G__GL_594_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableMenuBarHiding",1969,G__G__GL_594_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MenuHidingTimeout",1743,G__G__GL_594_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleMenuBarHiding",1865,G__G__GL_594_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'Event_t' - 0 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessFrameMessage",1935,G__G__GL_594_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
"l - 'Long_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrame",779,G__G__GL_594_0_21, 85, G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftVerticalFrame",2000,G__G__GL_594_0_22, 85, G__get_linked_tagnum(&G__G__GLLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFormat",905,G__G__GL_594_0_23, 85, G__get_linked_tagnum(&G__G__GLLN_TGLFormat), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleEditObject",1599,G__G__GL_594_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleOrthoRotate",1757,G__G__GL_594_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToggleOrthoDolly",1650,G__G__GL_594_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMenuHidingTimeout",2043,G__G__GL_594_0_27, 121, -1, -1, 0, 1, 3, 1, 0, "l - 'Long_t' 0 - timeout", (char*)NULL, (void*) G__func2void( (void (*)(Long_t))(&TGLSAViewer::SetMenuHidingTimeout) ), 0);
   G__memfunc_setup("Class",502,G__G__GL_594_0_28, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSAViewer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_594_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSAViewer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_594_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSAViewer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_594_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSAViewer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_594_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_594_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSAViewer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_594_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSAViewer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_594_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSAViewer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_594_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSAViewer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSAViewer", 1131, G__G__GL_594_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSAFrame(void) {
   /* TGLSAFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame));
   G__memfunc_setup("TGLSAFrame",870,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame), -1, 0, 1, 1, 4, 0, "u 'TGLSAFrame' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame), -1, 1, 1, 1, 4, 0, "u 'TGLSAFrame' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSAFrame",870,G__G__GL_595_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame), -1, 0, 1, 1, 1, 0, "u 'TGLSAViewer' - 1 - viewer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLSAFrame",870,G__G__GL_595_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSAFrame), -1, 0, 2, 1, 1, 0, 
"U 'TGWindow' - 10 - parent u 'TGLSAViewer' - 1 - viewer", (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__GL_595_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSAFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_595_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSAFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_595_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSAFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_595_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSAFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_595_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__GL_595_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSAFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_595_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSAFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_595_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSAFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_595_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSAFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSAFrame", 996, G__G__GL_595_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLScaleManip(void) {
   /* TGLScaleManip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip));
   G__memfunc_setup("LimitScale",999,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "d - 'Double_t' 1 - factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLScaleManip",1220,G__G__GL_599_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLScaleManip",1220,G__G__GL_599_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip), -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_599_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLScaleManip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_599_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScaleManip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_599_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLScaleManip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_599_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLScaleManip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_599_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__GL_599_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScaleManip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_599_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLScaleManip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_599_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScaleManip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_599_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLScaleManip::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLScaleManip", 1220, G__G__GL_599_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLScaleManip), -1, 0, 1, 1, 1, 0, "u 'TGLScaleManip' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLScaleManip", 1346, G__G__GL_599_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLScenecLcLTSceneInfo(void) {
   /* TGLScene::TSceneInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo));
   G__memfunc_setup("CmpDrawElements",1515,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"u 'TGLScene::DrawElement_t' - 11 - de1 u 'TGLScene::DrawElement_t' - 11 - de2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearDrawElementVec",1885,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'vector<TGLScene::DrawElement_t,allocator<TGLScene::DrawElement_t> >' 'TGLScene::DrawElementVec_t' 1 - vec i - 'Int_t' 0 - maxSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearDrawElementPtrVec",2195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'vector<TGLScene::DrawElement_t*,allocator<TGLScene::DrawElement_t*> >' 'TGLScene::DrawElementPtrVec_t' 1 - vec i - 'Int_t' 0 - maxSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSceneInfo",974,G__G__GL_637_0_4, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScenecLcLTSceneInfo), -1, 0, 2, 1, 1, 0, 
"U 'TGLViewerBase' - 0 '0' view U 'TGLScene' - 0 '0' scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearAfterRebuild",1696,G__G__GL_637_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearAfterUpdate",1596,G__G__GL_637_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lodify",615,G__G__GL_637_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - ctx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreDraw",693,G__G__GL_637_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PostDraw",820,G__G__GL_637_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetDrawStats",1440,G__G__GL_637_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateDrawStats",1536,G__G__GL_637_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLPhysicalShape' - 11 - shape s - 'Short_t' 0 - lod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpDrawStats",1331,G__G__GL_637_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "Debug", (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSceneInfo", 1100, G__G__GL_637_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLScenePad(void) {
   /* TGLScenePad */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLScenePad));
   G__memfunc_setup("TGLScenePad",1002,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScenePad), -1, 0, 1, 1, 4, 0, "u 'TGLScenePad' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLScenePad), -1, 1, 1, 1, 4, 0, "u 'TGLScenePad' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ValidateObjectBuffer",2011,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 8, 
"u 'TBuffer3D' - 11 - buffer g - 'Bool_t' 0 - includeRaw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNewLogical",1593,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 1, 1, 2, 8, "u 'TBuffer3D' - 11 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNewPhysical",1723,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TGLPhysicalShape), -1, 0, 3, 1, 2, 8, 
"h - 'UInt_t' 0 - physicalID u 'TBuffer3D' - 11 - buffer "
"u 'TGLLogicalShape' - 11 - logical", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildComposite",1443,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_RootCsgcLcLTBaseMesh), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AttemptDirectRenderer",2161,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShape), -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLScenePad",1002,G__G__GL_647_0_8, 105, G__get_linked_tagnum(&G__G__GLLN_TGLScenePad), -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPad",565,G__G__GL_647_0_9, 85, G__get_linked_tagnum(&G__G__GLLN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistoPhysical",1613,G__G__GL_647_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLLogicalShape' - 0 - log", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SubPadPaint",1083,G__G__GL_647_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PadPaintFromViewer",1815,G__G__GL_647_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLViewer' - 0 - viewer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSmartRefresh",1526,G__G__GL_647_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSmartRefresh",1538,G__G__GL_647_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - smart_ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanLoopOnPrimitives",1941,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PadPaint",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ObjectPaint",1107,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreferLocalFrame",1594,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginScene",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildingScene",1308,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EndScene",773,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddObject",864,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer3D' - 11 - buffer G - 'Bool_t' 0 '0' addChildren", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddObject",864,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - physicalID u 'TBuffer3D' - 11 - buffer "
"G - 'Bool_t' 0 '0' addChildren", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OpenComposite",1349,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TBuffer3D' - 11 - buffer G - 'Bool_t' 0 '0' addChildren", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloseComposite",1449,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddCompositeOp",1403,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - operation", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_647_0_29, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLScenePad::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_647_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScenePad::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_647_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLScenePad::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_647_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLScenePad::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_647_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_647_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScenePad::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_647_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLScenePad::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_647_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLScenePad::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_647_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLScenePad::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLScenePad", 1128, G__G__GL_647_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSphere(void) {
   /* TGLSphere */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSphere));
   G__memfunc_setup("TGLSphere",846,G__G__GL_658_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSphere), -1, 0, 1, 1, 1, 0, "u 'TBuffer3DSphere' - 11 - buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DLOffset",759,(G__InterfaceMethod) NULL,104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "s - 'Short_t' 0 - lod", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportedLODAxes",1590,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__GLLN_TGLLogicalShapecLcLELODAxes), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("QuantizeShapeLOD",1569,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Short_t"), 0, 2, 1, 1, 8, 
"s - 'Short_t' 0 - shapeLOD s - 'Short_t' 0 - combiLOD", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_658_0_6, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSphere::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_658_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSphere::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_658_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSphere::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_658_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSphere::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_658_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__GL_658_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSphere::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_658_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSphere::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_658_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSphere::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_658_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSphere::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSphere", 972, G__G__GL_658_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLSurfacePainter(void) {
   /* TGLSurfacePainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter));
   G__memfunc_setup("TGLSurfacePainter",1667,G__G__GL_660_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLSurfacePainter), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - hist U 'TGLPlotCamera' - 0 - camera "
"U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - stringOption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNormals",1032,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSurfaceColor",1524,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometryCartesian",2170,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometryPolar",1758,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometryCylindrical",2382,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGeometrySpherical",2171,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawProjections",1566,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClampZ",583,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "d - 'Double_t' 1 - zVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowPointTo3DPoint",1990,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 2, 1, 4, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreparePalette",1438,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenTexMap",873,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawContoursProjection",2312,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Textured",853,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasSections",1124,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasProjections",1452,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPalette",1117,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPaletteAxis",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_660_0_31, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLSurfacePainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_660_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSurfacePainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_660_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLSurfacePainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_660_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLSurfacePainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_660_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__GL_660_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSurfacePainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_660_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSurfacePainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_660_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLSurfacePainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_660_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLSurfacePainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLSurfacePainter", 1793, G__G__GL_660_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLTF3Painter(void) {
   /* TGLTF3Painter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter));
   G__memfunc_setup("TGLTF3Painter",1159,G__G__GL_688_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTF3Painter), -1, 0, 4, 1, 1, 0, 
"U 'TF3' - 0 - fun U 'TH1' - 0 - hist "
"U 'TGLPlotCamera' - 0 - camera U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - stringOption", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawToSelectionBuffer",2129,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawDefaultPlot",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawMaplePlot",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSurfaceColor",1524,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasSections",1124,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_688_0_19, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLTF3Painter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_688_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTF3Painter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_688_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLTF3Painter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_688_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLTF3Painter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_688_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__GL_688_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTF3Painter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_688_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTF3Painter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_688_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTF3Painter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_688_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTF3Painter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLTF3Painter", 1285, G__G__GL_688_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLIsoPainter(void) {
   /* TGLIsoPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter));
   G__memfunc_setup("TGLIsoPainter",1253,G__G__GL_691_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - hist U 'TGLPlotCamera' - 0 - camera "
"U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasSections",1124,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSurfaceColor",1524,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMesh",697,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'Rgl::Mc::TIsoMesh<float>' 'TGLIsoPainter::Mesh_t' 1 - mesh d - 'Double_t' 0 - isoValue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawMesh",795,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'Rgl::Mc::TIsoMesh<float>' 'TGLIsoPainter::Mesh_t' 11 - mesh i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMinMax",971,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLIsoPainter",1253,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter), -1, 0, 1, 1, 4, 0, "u 'TGLIsoPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLIsoPainter), -1, 1, 1, 1, 4, 0, "u 'TGLIsoPainter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_691_0_21, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLIsoPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_691_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLIsoPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_691_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLIsoPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_691_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLIsoPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_691_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__GL_691_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLIsoPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_691_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLIsoPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_691_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLIsoPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_691_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLIsoPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLIsoPainter", 1379, G__G__GL_691_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLTH3CompositionPainter(void) {
   /* TGLTH3CompositionPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter));
   G__memfunc_setup("TGLTH3CompositionPainter",2333,G__G__GL_721_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter), -1, 0, 3, 1, 1, 0, 
"U 'TGLTH3Composition' - 0 - data U 'TGLPlotCamera' - 0 - camera "
"U 'TGLPlotCoordinates' - 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartPan",813,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Pan",287,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddOption",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessEvent",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGL",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeInitGL",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPlot",813,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOZ",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionYOZ",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawSectionXOY",1379,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColor",811,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "i - 'Int_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLTH3CompositionPainter",2333,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter), -1, 0, 1, 1, 4, 0, "u 'TGLTH3CompositionPainter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TGLTH3CompositionPainter), -1, 1, 1, 1, 4, 0, "u 'TGLTH3CompositionPainter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_721_0_17, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLTH3CompositionPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_721_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3CompositionPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_721_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLTH3CompositionPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_721_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLTH3CompositionPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_721_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__GL_721_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3CompositionPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_721_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTH3CompositionPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_721_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTH3CompositionPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_721_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTH3CompositionPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGLTH3CompositionPainter", 2459, G__G__GL_721_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGLTransManip(void) {
   /* TGLTransManip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TGLTransManip));
   G__memfunc_setup("TGLTransManip",1252,G__G__GL_728_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTransManip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGLTransManip",1252,G__G__GL_728_0_2, 105, G__get_linked_tagnum(&G__G__GLLN_TGLTransManip), -1, 0, 1, 1, 1, 0, "U 'TGLPhysicalShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleMotion",1218,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'Event_t' - 11 - event u 'TGLCamera' - 11 - camera", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_728_0_5, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGLTransManip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_728_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTransManip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_728_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGLTransManip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_728_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGLTransManip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_728_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__GL_728_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTransManip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_728_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTransManip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_728_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGLTransManip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_728_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGLTransManip::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGLTransManip", 1252, G__G__GL_728_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__GLLN_TGLTransManip), -1, 0, 1, 1, 1, 0, "u 'TGLTransManip' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGLTransManip", 1378, G__G__GL_728_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2GL(void) {
   /* TH2GL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TH2GL));
   G__memfunc_setup("TH2GL",353,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TH2GL), -1, 0, 1, 1, 4, 0, "u 'TH2GL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TH2GL), -1, 1, 1, 1, 4, 0, "u 'TH2GL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TH2GL",353,G__G__GL_737_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TH2GL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_737_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2GL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_737_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2GL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_737_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2GL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_737_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2GL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_737_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__GL_737_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2GL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_737_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2GL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_737_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2GL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_737_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2GL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2GL", 479, G__G__GL_737_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3GL(void) {
   /* TH3GL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TH3GL));
   G__memfunc_setup("TH3GL",354,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TH3GL), -1, 0, 1, 1, 4, 0, "u 'TH3GL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TH3GL), -1, 1, 1, 1, 4, 0, "u 'TH3GL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TH3GL",354,G__G__GL_738_0_3, 105, G__get_linked_tagnum(&G__G__GLLN_TH3GL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_738_0_7, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3GL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_738_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3GL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_738_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3GL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_738_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3GL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_738_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__GL_738_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3GL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_738_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3GL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_738_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3GL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_738_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3GL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3GL", 480, G__G__GL_738_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPointSet3DGL(void) {
   /* TPointSet3DGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL));
   G__memfunc_setup("TPointSet3DGL",1172,G__G__GL_739_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TPointSet3DGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreSizeForOfInterest",2345,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShouldDLCache",1235,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 11 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__GL_739_0_10, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPointSet3DGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_739_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointSet3DGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_739_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPointSet3DGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_739_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPointSet3DGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_739_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__GL_739_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointSet3DGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_739_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPointSet3DGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_739_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointSet3DGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_739_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPointSet3DGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPointSet3DGL", 1298, G__G__GL_739_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTX11GLManager(void) {
   /* TX11GLManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GLLN_TX11GLManager));
   G__memfunc_setup("TX11GLManager",1116,G__G__GL_742_0_1, 105, G__get_linked_tagnum(&G__G__GLLN_TX11GLManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGLWindow",1183,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "k - 'Window_t' 0 - winID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateGLContext",1484,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - winInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachOffScreenDevice",2080,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ctxInd 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("ResizeOffScreenDevice",2109,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - devInd 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("SelectOffScreenDevice",2091,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - devInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVirtualXInd",1402,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - devInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MarkForDirectCopy",1704,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - devInd g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExtractViewport",1595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - devInd I - 'Int_t' 0 - vp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadGLBuffer",1129,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - devInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCurrent",1121,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - devInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Flush",514,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ctxInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteGLContext",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - devInd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectManip",1109,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"U 'TVirtualGLManip' - 0 - manip U 'TGLCamera' - 10 - camera "
"U 'TGLRect' - 10 - rect U 'TGLBoundingBox' - 10 - sceneBox", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PlotSelected",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"U 'TVirtualGLPainter' - 0 - plot i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlotInfo",1099,(G__InterfaceMethod) NULL,67, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualGLPainter' - 0 - plot i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintSingleObject",1717,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualGLPainter' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PanObject",886,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualGLPainter' - 0 - o i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintViewer",1151,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualViewer3D' - 0 - vv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HighColorFormat",1512,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateGLPixmap",1366,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "u 'TX11GLManager::TGLContext_t' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TX11GLManager",1116,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GLLN_TX11GLManager), -1, 0, 1, 1, 4, 0, "u 'TX11GLManager' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GLLN_TX11GLManager), -1, 1, 1, 1, 4, 0, "u 'TX11GLManager' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__GL_742_0_24, 85, G__get_linked_tagnum(&G__G__GLLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TX11GLManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__GL_742_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TX11GLManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__GL_742_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TX11GLManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__GL_742_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TX11GLManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GLLN_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__GL_742_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__GL_742_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TX11GLManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__GL_742_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TX11GLManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__GL_742_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TX11GLManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__GL_742_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TX11GLManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TX11GLManager", 1242, G__G__GL_742_0_36, (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__GL() {
}

/*********************************************************
* 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() {
}

static void G__cpp_setup_global4() {
}

static void G__cpp_setup_global5() {
}

static void G__cpp_setup_global6() {
}

static void G__cpp_setup_global7() {
}

static void G__cpp_setup_global8() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__GL() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
  G__cpp_setup_global7();
  G__cpp_setup_global8();
}

/*********************************************************
* 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() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__GL() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__GLLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TPoint = { "TPoint" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TArcBall = { "TArcBall" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLBoundingBox = { "TGLBoundingBox" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLCamera = { "TGLCamera" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__GLLN_GLUtesselator = { "GLUtesselator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_EOverlap = { "EOverlap" , 101 , -1 };
G__linked_taginfo G__G__GLLN_EClipType = { "EClipType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_EGLCoordType = { "EGLCoordType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_EGLPlotType = { "EGLPlotType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLVector3 = { "TGLVector3" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLVertex3 = { "TGLVertex3" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLine3 = { "TGLLine3" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLRect = { "TGLRect" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlane = { "TGLPlane" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR = { "vector<TGLPlane,allocator<TGLPlane> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLPlane,allocator<TGLPlane> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEboolcOTGLLine3gR = { "pair<bool,TGLLine3>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_pairlEboolcOTGLVertex3gR = { "pair<bool,TGLVertex3>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_TGLMatrix = { "TGLMatrix" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLColor = { "TGLColor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLColorSet = { "TGLColorSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLUtil = { "TGLUtil" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLUtilcLcLTColorLocker = { "TGLUtil::TColorLocker" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLUtilcLcLTDrawQualityModifier = { "TGLUtil::TDrawQualityModifier" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLUtilcLcLTDrawQualityScaler = { "TGLUtil::TDrawQualityScaler" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLUtilcLcLELineHeadShape = { "TGLUtil::ELineHeadShape" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLUtilcLcLEAxesType = { "TGLUtil::EAxesType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLSelectionBuffer = { "TGLSelectionBuffer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR = { "vector<unsigned char,allocator<unsigned char> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned char,allocator<unsigned char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlotCoordinates = { "TGLPlotCoordinates" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLQuadric = { "TGLQuadric" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TAxis = { "TAxis" , 99 , -1 };
G__linked_taginfo G__G__GLLN_Rgl = { "Rgl" , 110 , -1 };
G__linked_taginfo G__G__GLLN_pairlEintcOintgR = { "pair<int,int>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLevelPalette = { "TGLLevelPalette" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLBoundingBoxcLcLEFace = { "TGLBoundingBox::EFace" , 101 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TBuffer3D = { "TBuffer3D" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TContextMenu = { "TContextMenu" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPhysicalShape = { "TGLPhysicalShape" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLRnrCtx = { "TGLRnrCtx" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSelectRecord = { "TGLSelectRecord" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewer = { "TGLViewer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSceneBase = { "TGLSceneBase" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLScene = { "TGLScene" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLogicalShape = { "TGLLogicalShape" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLogicalShapecLcLELODAxes = { "TGLLogicalShape::ELODAxes" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__GLLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_TGLObject = { "TGLObject" , 99 , -1 };
G__linked_taginfo G__G__GLLN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualViewer3D = { "TVirtualViewer3D" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLManip = { "TGLManip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualGLPainter = { "TVirtualGLPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualGLManip = { "TVirtualGLManip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLManager = { "TGLManager" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLContext = { "TGLContext" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFormat = { "TGLFormat" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPaintDevice = { "TGLPaintDevice" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TColor = { "TColor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlotBox = { "TGLPlotBox" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlotCamera = { "TGLPlotCamera" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL5DDataSet = { "TGL5DDataSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TH3 = { "TH3" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TF3 = { "TF3" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLBoxCut = { "TGLBoxCut" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTH3Slice = { "TGLTH3Slice" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTH3SlicecLcLESliceAxis = { "TGLTH3Slice::ESliceAxis" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGL2DArraylEdoublegR = { "TGL2DArray<double>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlotPainter = { "TGLPlotPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlotPaintercLcLESelectionBase = { "TGLPlotPainter::ESelectionBase" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlotPaintercLcLECutAxisID = { "TGLPlotPainter::ECutAxisID" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TH2Poly = { "TH2Poly" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPlot3D = { "TGLPlot3D" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TF2 = { "TF2" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TF2GL = { "TF2GL" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TAttText = { "TAttText" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGGroupFrame = { "TGGroupFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGToolTip = { "TGToolTip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGedEditor = { "TGedEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGedFrame = { "TGedFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGNumberEntryField = { "TGNumberEntryField" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGDoubleHSlider = { "TGDoubleHSlider" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGColorSelect = { "TGColorSelect" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL5DPainter = { "TGL5DPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGListBox = { "TGListBox" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGHSlider = { "TGHSlider" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL5DDataSetEditor = { "TGL5DDataSetEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL5DDataSetEditorcLcLTGL5DEditorPrivate = { "TGL5DDataSetEditor::TGL5DEditorPrivate" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualHistPainter = { "TVirtualHistPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLParametricEquation = { "TGLParametricEquation" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTH3Composition = { "TGLTH3Composition" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLHistPainter = { "TGLHistPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_auto_ptrlETVirtualHistPaintergR = { "auto_ptr<TVirtualHistPainter>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_auto_ptrlETGLPlotPaintergR = { "auto_ptr<TGLPlotPainter>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLHistPaintercLcLPlotOption_t = { "TGLHistPainter::PlotOption_t" , 115 , -1 };
G__linked_taginfo G__G__GLLN_TAttAxis = { "TAttAxis" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TArray = { "TArray" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL5DDataSetcLcLEdefaults = { "TGL5DDataSet::Edefaults" , 101 , -1 };
G__linked_taginfo G__G__GLLN_auto_ptrlETGLHistPaintergR = { "auto_ptr<TGLHistPainter>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAdapter = { "TGLAdapter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLOvlSelectRecord = { "TGLOvlSelectRecord" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLOverlayElement = { "TGLOverlayElement" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLOverlayElementcLcLERole = { "TGLOverlayElement::ERole" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLOverlayElementcLcLEState = { "TGLOverlayElement::EState" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLOverlayList = { "TGLOverlayList" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR = { "list<TGLOverlayElement*,allocator<TGLOverlayElement*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_FTFont = { "FTFont" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFontManager = { "TGLFontManager" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFont = { "TGLFont" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFontcLcLEMode = { "TGLFont::EMode" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLFontcLcLETextAlignH_e = { "TGLFont::ETextAlignH_e" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLFontcLcLETextAlignV_e = { "TGLFont::ETextAlignV_e" , 101 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR = { "map<TGLFont,int,less<TGLFont>,allocator<pair<const TGLFont,int> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgRcLcLiterator = { "map<TGLFont,int,less<TGLFont>,allocator<pair<const TGLFont,int> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR = { "list<const TGLFont*,allocator<const TGLFont*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgRcLcLiterator = { "list<const TGLFont*,allocator<const TGLFont*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewerBase = { "TGLViewerBase" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGTextEdit = { "TGTextEdit" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAnnotation = { "TGLAnnotation" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAnnotationcLcLEDrag = { "TGLAnnotation::EDrag" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLAnnotationcLcLENameStack = { "TGLAnnotation::ENameStack" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAutoRotator = { "TGLAutoRotator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLText = { "TGLText" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAxis = { "TGLAxis" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TPMERegexp = { "TPMERegexp" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAxisPainter = { "TGLAxisPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEfloatcOfloatgR = { "pair<float,float>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR = { "vector<pair<float,float>,allocator<pair<float,float> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,float>,allocator<pair<float,float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEfloatcOintgR = { "pair<float,int>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR = { "vector<pair<float,int>,allocator<pair<float,int> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,int>,allocator<pair<float,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLAxisPainterBox = { "TGLAxisPainterBox" , 99 , -1 };
G__linked_taginfo G__G__GLLN_GLUquadric = { "GLUquadric" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLBoxPainter = { "TGLBoxPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLBoxPaintercLcLEBoxType = { "TGLBoxPainter::EBoxType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLCameraGuide = { "TGLCameraGuide" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLCameracLcLEFrustumPlane = { "TGLCamera::EFrustumPlane" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLCameraOverlay = { "TGLCameraOverlay" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLCameraOverlaycLcLEMode = { "TGLCameraOverlay::EMode" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLPShapeRef = { "TGLPShapeRef" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPhysicalShapecLcLEManip = { "TGLPhysicalShape::EManip" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLManipSet = { "TGLManipSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLClip = { "TGLClip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLClipcLcLEMode = { "TGLClip::EMode" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLClipPlane = { "TGLClipPlane" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLClipBox = { "TGLClipBox" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLClipSet = { "TGLClipSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGButtonGroup = { "TGButtonGroup" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLClipSetSubEditor = { "TGLClipSetSubEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLClipSetEditor = { "TGLClipSetEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLContextIdentity = { "TGLContextIdentity" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFormatcLcLEFormatOptions = { "TGLFormat::EFormatOptions" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLContextPrivate = { "TGLContextPrivate" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLWidget = { "TGLWidget" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEunsignedsPintcOintgR = { "pair<unsigned int,int>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR = { "list<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiterator = { "list<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLContextmUcOallocatorlETGLContextmUgRsPgR = { "list<TGLContext*,allocator<TGLContext*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TBuffer3DTube = { "TBuffer3DTube" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLCylinder = { "TGLCylinder" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLockable = { "TGLLockable" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLockablecLcLELock = { "TGLLockable::ELock" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLSceneInfo = { "TGLSceneInfo" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR = { "list<TGLSceneInfo*,allocator<TGLSceneInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator = { "list<TGLSceneInfo*,allocator<TGLSceneInfo*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR = { "vector<TGLSceneInfo*,allocator<TGLSceneInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator = { "vector<TGLSceneInfo*,allocator<TGLSceneInfo*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLSceneInfo*,allocator<TGLSceneInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR = { "vector<TGLOverlayElement*,allocator<TGLOverlayElement*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiterator = { "vector<TGLOverlayElement*,allocator<TGLOverlayElement*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLOverlayElement*,allocator<TGLOverlayElement*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLStopwatch = { "TGLStopwatch" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSelectBuffer = { "TGLSelectBuffer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLRnrCtxcLcLEStyle = { "TGLRnrCtx::EStyle" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLRnrCtxcLcLEPass = { "TGLRnrCtx::EPass" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLRnrCtxcLcLELODPresets = { "TGLRnrCtx::ELODPresets" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel = { "TGLRnrCtx::EShapeSelectionLevel" , 101 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR = { "list<TGLColorSet*,allocator<TGLColorSet*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSelectRecordBase = { "TGLSelectRecordBase" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSelectRecordcLcLESecSelResult = { "TGLSelectRecord::ESecSelResult" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TBuffer3DSphere = { "TBuffer3DSphere" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPerspectiveCamera = { "TGLPerspectiveCamera" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLOrthoCamera = { "TGLOrthoCamera" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLOrthoCameracLcLEType = { "TGLOrthoCamera::EType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGEventHandler = { "TGEventHandler" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLRedrawTimer = { "TGLRedrawTimer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewerEditor = { "TGLViewerEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLightSet = { "TGLLightSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPShapeObj = { "TGLPShapeObj" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLOutput = { "TGLOutput" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLEventHandler = { "TGLEventHandler" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewercLcLECameraType = { "TGLViewer::ECameraType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewercLcLESecSelType = { "TGLViewer::ESecSelType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewercLcLEPushAction = { "TGLViewer::EPushAction" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLViewercLcLEDragAction = { "TGLViewer::EDragAction" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLFaderHelper = { "TGLFaderHelper" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLEmbeddedViewer = { "TGLEmbeddedViewer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RootCsg = { "RootCsg" , 110 , -1 };
G__linked_taginfo G__G__GLLN_RootCsgcLcLTBaseMesh = { "RootCsg::TBaseMesh" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFaceSet = { "TGLFaceSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLFBO = { "TGLFBO" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPadPainter = { "TGLPadPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLPad = { "Rgl::Pad" , 110 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLPadcLcLPolygonStippleSet = { "Rgl::Pad::PolygonStippleSet" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLPadcLcLMarkerPainter = { "Rgl::Pad::MarkerPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR = { "vector<TPoint,allocator<TPoint> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETPointcOallocatorlETPointgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TPoint,allocator<TPoint> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgR = { "list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLPadcLcLTesselator = { "Rgl::Pad::Tesselator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLPadcLcLGLLimits = { "Rgl::Pad::GLLimits" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TMultiGraph = { "TMultiGraph" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLH2PolyPainter = { "TGLH2PolyPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgR = { "list<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> >,allocator<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> > > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgRcLcLiterator = { "list<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> >,allocator<list<Rgl::Pad::MeshPatch_t,allocator<Rgl::Pad::MeshPatch_t> > > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLegoPainter = { "TGLLegoPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLegoPaintercLcLELegoType = { "TGLLegoPainter::ELegoType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR = { "vector<pair<double,double>,allocator<pair<double,double> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,double>,allocator<pair<double,double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLightSetSubEditor = { "TGLLightSetSubEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLightSetEditor = { "TGLLightSetEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLLightSetcLcLELight = { "TGLLightSet::ELight" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLManipSetcLcLEManip = { "TGLManipSet::EManip" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLOutputcLcLEFormat = { "TGLOutput::EFormat" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLOverlayButton = { "TGLOverlayButton" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualPadPainter = { "TVirtualPadPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualPadPaintercLcLEBoxMode = { "TVirtualPadPainter::EBoxMode" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TVirtualPadPaintercLcLETextMode = { "TVirtualPadPainter::ETextMode" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLParametricEquationGL = { "TGLParametricEquationGL" , 99 , -1 };
G__linked_taginfo G__G__GLLN_auto_ptrlETF2gR = { "auto_ptr<TF2>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLParametricPlot = { "TGLParametricPlot" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLParametricPlotcLcLEMeshSize = { "TGLParametricPlot::EMeshSize" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGL2DArraylETGLParametricPlotcLcLVertex_tgR = { "TGL2DArray<TGLParametricPlot::Vertex_t>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgR = { "vector<TGLParametricPlot::Vertex_t,allocator<TGLParametricPlot::Vertex_t> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLParametricPlot::Vertex_t,allocator<TGLParametricPlot::Vertex_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPolyLine = { "TGLPolyLine" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPolyMarker = { "TGLPolyMarker" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPShapeObjEditor = { "TGLPShapeObjEditor" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLPShapeObjEditorcLcLELightMode = { "TGLPShapeObjEditor::ELightMode" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLRotateManip = { "TGLRotateManip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSAViewer = { "TGLSAViewer" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSAFrame = { "TGLSAFrame" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSAViewercLcLEGLSACommands = { "TGLSAViewer::EGLSACommands" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGLScaleManip = { "TGLScaleManip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgR = { "list<TGLViewerBase*,allocator<TGLViewerBase*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgRcLcLiterator = { "list<TGLViewerBase*,allocator<TGLViewerBase*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSceneInfocLcLEClipTest = { "TGLSceneInfo::EClipTest" , 101 , -1 };
G__linked_taginfo G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR = { "map<TObject*,TGLLogicalShape*,less<TObject*>,allocator<pair<TObject* const,TGLLogicalShape*> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlETObjectmUcOTGLLogicalShapemUgR = { "pair<TObject*,TGLLogicalShape*>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgRcLcLiterator = { "map<TObject*,TGLLogicalShape*,less<TObject*>,allocator<pair<TObject* const,TGLLogicalShape*> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR = { "map<unsigned int,TGLPhysicalShape*,less<unsigned int>,allocator<pair<const unsigned int,TGLPhysicalShape*> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEunsignedsPintcOTGLPhysicalShapemUgR = { "pair<unsigned int,TGLPhysicalShape*>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgRcLcLiterator = { "map<unsigned int,TGLPhysicalShape*,less<unsigned int>,allocator<pair<const unsigned int,TGLPhysicalShape*> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLScenecLcLDrawElement_t = { "TGLScene::DrawElement_t" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR = { "vector<TGLScene::DrawElement_t,allocator<TGLScene::DrawElement_t> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiterator = { "vector<TGLScene::DrawElement_t,allocator<TGLScene::DrawElement_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLScene::DrawElement_t,allocator<TGLScene::DrawElement_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR = { "vector<TGLScene::DrawElement_t*,allocator<TGLScene::DrawElement_t*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiterator = { "vector<TGLScene::DrawElement_t*,allocator<TGLScene::DrawElement_t*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLScene::DrawElement_t*,allocator<TGLScene::DrawElement_t*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR = { "vector<const TGLPhysicalShape*,allocator<const TGLPhysicalShape*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiterator = { "vector<const TGLPhysicalShape*,allocator<const TGLPhysicalShape*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TGLPhysicalShape*,allocator<const TGLPhysicalShape*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLScenecLcLTSceneInfo = { "TGLScene::TSceneInfo" , 99 , -1 };
G__linked_taginfo G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR = { "map<TClass*,unsigned int,less<TClass*>,allocator<pair<TClass* const,unsigned int> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLScenePad = { "TGLScenePad" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgR = { "pair<unsigned int,RootCsg::TBaseMesh*>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR = { "vector<pair<unsigned int,RootCsg::TBaseMesh*>,allocator<pair<unsigned int,RootCsg::TBaseMesh*> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,RootCsg::TBaseMesh*>,allocator<pair<unsigned int,RootCsg::TBaseMesh*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEunsignedsPintcOunsignedsPintmUgR = { "pair<unsigned int,unsigned int*>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR = { "vector<pair<unsigned int,unsigned int*>,allocator<pair<unsigned int,unsigned int*> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,unsigned int*>,allocator<pair<unsigned int,unsigned int*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSphere = { "TGLSphere" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSurfacePainter = { "TGLSurfacePainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSurfacePaintercLcLESurfaceType = { "TGLSurfacePainter::ESurfaceType" , 101 , -1 };
G__linked_taginfo G__G__GLLN_TGL2DArraylETGLVertex3gR = { "TGL2DArray<TGLVertex3>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLVertex3cOallocatorlETGLVertex3gRsPgR = { "vector<TGLVertex3,allocator<TGLVertex3> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLVertex3cOallocatorlETGLVertex3gRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLVertex3,allocator<TGLVertex3> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL2DArraylEpairlETGLVector3cOTGLVector3gRsPgR = { "TGL2DArray<pair<TGLVector3,TGLVector3> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgR = { "vector<pair<TGLVector3,TGLVector3>,allocator<pair<TGLVector3,TGLVector3> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<TGLVector3,TGLVector3>,allocator<pair<TGLVector3,TGLVector3> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGL2DArraylETGLVector3gR = { "TGL2DArray<TGLVector3>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_vectorlETGLVector3cOallocatorlETGLVector3gRsPgR = { "vector<TGLVector3,allocator<TGLVector3> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlETGLVector3cOallocatorlETGLVector3gRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLVector3,allocator<TGLVector3> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLSurfacePaintercLcLProjection_t = { "TGLSurfacePainter::Projection_t" , 115 , -1 };
G__linked_taginfo G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR = { "list<TGLSurfacePainter::Projection_t,allocator<TGLSurfacePainter::Projection_t> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLMc = { "Rgl::Mc" , 110 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTF3Painter = { "TGLTF3Painter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTF3PaintercLcLETF3Style = { "TGLTF3Painter::ETF3Style" , 101 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLMccLcLTIsoMeshlEdoublegR = { "Rgl::Mc::TIsoMesh<double>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLIsoPainter = { "TGLIsoPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_RglcLcLMccLcLTIsoMeshlEfloatgR = { "Rgl::Mc::TIsoMesh<float>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR = { "list<Rgl::Mc::TIsoMesh<float>,allocator<Rgl::Mc::TIsoMesh<float> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgRcLcLiterator = { "list<Rgl::Mc::TIsoMesh<float>,allocator<Rgl::Mc::TIsoMesh<float> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TArrayC = { "TArrayC" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TH3C = { "TH3C" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTH3CompositionPainter = { "TGLTH3CompositionPainter" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTH3CompositioncLcLETH3BinShape = { "TGLTH3Composition::ETH3BinShape" , 101 , -1 };
G__linked_taginfo G__G__GLLN_pairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegR = { "pair<const TH3*,TGLTH3Composition::ETH3BinShape>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR = { "vector<pair<const TH3*,TGLTH3Composition::ETH3BinShape>,allocator<pair<const TH3*,TGLTH3Composition::ETH3BinShape> > >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_reverse_iteratorlEvectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<const TH3*,TGLTH3Composition::ETH3BinShape>,allocator<pair<const TH3*,TGLTH3Composition::ETH3BinShape> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGLTransManip = { "TGLTransManip" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__GLLN_pairlEvoidmUcOvoidmUgR = { "pair<void*,void*>" , 115 , -1 };
G__linked_taginfo G__G__GLLN_setlETGLContextmUcOlesslETGLContextmUgRcOallocatorlETGLContextmUgRsPgR = { "set<TGLContext*,less<TGLContext*>,allocator<TGLContext*> >" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TH2GL = { "TH2GL" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TH3GL = { "TH3GL" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TPointSet3DGL = { "TPointSet3DGL" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TX11GLManager = { "TX11GLManager" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TX11GLManagercLcLTX11GLImpl = { "TX11GLManager::TX11GLImpl" , 99 , -1 };
G__linked_taginfo G__G__GLLN_TX11GLManagercLcLTGLContext_t = { "TX11GLManager::TGLContext_t" , 115 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__GL() {
  G__G__GLLN_TClass.tagnum = -1 ;
  G__G__GLLN_TBuffer.tagnum = -1 ;
  G__G__GLLN_TMemberInspector.tagnum = -1 ;
  G__G__GLLN_TObject.tagnum = -1 ;
  G__G__GLLN_TNamed.tagnum = -1 ;
  G__G__GLLN_TString.tagnum = -1 ;
  G__G__GLLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TList.tagnum = -1 ;
  G__G__GLLN_TObjArray.tagnum = -1 ;
  G__G__GLLN_TTimer.tagnum = -1 ;
  G__G__GLLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TPoint.tagnum = -1 ;
  G__G__GLLN_TArcBall.tagnum = -1 ;
  G__G__GLLN_TGLBoundingBox.tagnum = -1 ;
  G__G__GLLN_TGLCamera.tagnum = -1 ;
  G__G__GLLN_TAttMarker.tagnum = -1 ;
  G__G__GLLN_TAttLine.tagnum = -1 ;
  G__G__GLLN_GLUtesselator.tagnum = -1 ;
  G__G__GLLN_EOverlap.tagnum = -1 ;
  G__G__GLLN_EClipType.tagnum = -1 ;
  G__G__GLLN_EGLCoordType.tagnum = -1 ;
  G__G__GLLN_EGLPlotType.tagnum = -1 ;
  G__G__GLLN_TGLVector3.tagnum = -1 ;
  G__G__GLLN_TGLVertex3.tagnum = -1 ;
  G__G__GLLN_TGLLine3.tagnum = -1 ;
  G__G__GLLN_TGLRect.tagnum = -1 ;
  G__G__GLLN_TGLPlane.tagnum = -1 ;
  G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_pairlEboolcOTGLLine3gR.tagnum = -1 ;
  G__G__GLLN_pairlEboolcOTGLVertex3gR.tagnum = -1 ;
  G__G__GLLN_TGLMatrix.tagnum = -1 ;
  G__G__GLLN_TGLColor.tagnum = -1 ;
  G__G__GLLN_TGLColorSet.tagnum = -1 ;
  G__G__GLLN_TGLUtil.tagnum = -1 ;
  G__G__GLLN_TGLUtilcLcLTColorLocker.tagnum = -1 ;
  G__G__GLLN_TGLUtilcLcLTDrawQualityModifier.tagnum = -1 ;
  G__G__GLLN_TGLUtilcLcLTDrawQualityScaler.tagnum = -1 ;
  G__G__GLLN_TGLUtilcLcLELineHeadShape.tagnum = -1 ;
  G__G__GLLN_TGLUtilcLcLEAxesType.tagnum = -1 ;
  G__G__GLLN_TGLSelectionBuffer.tagnum = -1 ;
  G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLPlotCoordinates.tagnum = -1 ;
  G__G__GLLN_TGLQuadric.tagnum = -1 ;
  G__G__GLLN_TAxis.tagnum = -1 ;
  G__G__GLLN_Rgl.tagnum = -1 ;
  G__G__GLLN_pairlEintcOintgR.tagnum = -1 ;
  G__G__GLLN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLLevelPalette.tagnum = -1 ;
  G__G__GLLN_TGLBoundingBoxcLcLEFace.tagnum = -1 ;
  G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TBuffer3D.tagnum = -1 ;
  G__G__GLLN_TContextMenu.tagnum = -1 ;
  G__G__GLLN_TGLPhysicalShape.tagnum = -1 ;
  G__G__GLLN_TGLRnrCtx.tagnum = -1 ;
  G__G__GLLN_TGLSelectRecord.tagnum = -1 ;
  G__G__GLLN_TGLViewer.tagnum = -1 ;
  G__G__GLLN_TGLSceneBase.tagnum = -1 ;
  G__G__GLLN_TGLScene.tagnum = -1 ;
  G__G__GLLN_TGLLogicalShape.tagnum = -1 ;
  G__G__GLLN_TGLLogicalShapecLcLELODAxes.tagnum = -1 ;
  G__G__GLLN_TMap.tagnum = -1 ;
  G__G__GLLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__GLLN_TGLObject.tagnum = -1 ;
  G__G__GLLN_Event_t.tagnum = -1 ;
  G__G__GLLN_TVirtualViewer3D.tagnum = -1 ;
  G__G__GLLN_TGLManip.tagnum = -1 ;
  G__G__GLLN_TVirtualGLPainter.tagnum = -1 ;
  G__G__GLLN_TVirtualGLManip.tagnum = -1 ;
  G__G__GLLN_TGLManager.tagnum = -1 ;
  G__G__GLLN_TGLContext.tagnum = -1 ;
  G__G__GLLN_TGLFormat.tagnum = -1 ;
  G__G__GLLN_TGLPaintDevice.tagnum = -1 ;
  G__G__GLLN_TColor.tagnum = -1 ;
  G__G__GLLN_TGLPlotBox.tagnum = -1 ;
  G__G__GLLN_TGLPlotCamera.tagnum = -1 ;
  G__G__GLLN_TGL5DDataSet.tagnum = -1 ;
  G__G__GLLN_TH1.tagnum = -1 ;
  G__G__GLLN_TH3.tagnum = -1 ;
  G__G__GLLN_TF3.tagnum = -1 ;
  G__G__GLLN_TGLBoxCut.tagnum = -1 ;
  G__G__GLLN_TGLTH3Slice.tagnum = -1 ;
  G__G__GLLN_TGLTH3SlicecLcLESliceAxis.tagnum = -1 ;
  G__G__GLLN_TGL2DArraylEdoublegR.tagnum = -1 ;
  G__G__GLLN_TGLPlotPainter.tagnum = -1 ;
  G__G__GLLN_TGLPlotPaintercLcLESelectionBase.tagnum = -1 ;
  G__G__GLLN_TGLPlotPaintercLcLECutAxisID.tagnum = -1 ;
  G__G__GLLN_TH2Poly.tagnum = -1 ;
  G__G__GLLN_TVirtualPad.tagnum = -1 ;
  G__G__GLLN_TGLPlot3D.tagnum = -1 ;
  G__G__GLLN_TF2.tagnum = -1 ;
  G__G__GLLN_TH2.tagnum = -1 ;
  G__G__GLLN_TF2GL.tagnum = -1 ;
  G__G__GLLN_TGObject.tagnum = -1 ;
  G__G__GLLN_TQObject.tagnum = -1 ;
  G__G__GLLN_TGWindow.tagnum = -1 ;
  G__G__GLLN_TAttFill.tagnum = -1 ;
  G__G__GLLN_TAttText.tagnum = -1 ;
  G__G__GLLN_TGFrame.tagnum = -1 ;
  G__G__GLLN_TGCompositeFrame.tagnum = -1 ;
  G__G__GLLN_TGLayoutHints.tagnum = -1 ;
  G__G__GLLN_TGTextButton.tagnum = -1 ;
  G__G__GLLN_TGVerticalFrame.tagnum = -1 ;
  G__G__GLLN_TGMainFrame.tagnum = -1 ;
  G__G__GLLN_TGGroupFrame.tagnum = -1 ;
  G__G__GLLN_TGToolTip.tagnum = -1 ;
  G__G__GLLN_TGedEditor.tagnum = -1 ;
  G__G__GLLN_TGedFrame.tagnum = -1 ;
  G__G__GLLN_TGNumberEntryField.tagnum = -1 ;
  G__G__GLLN_TGDoubleHSlider.tagnum = -1 ;
  G__G__GLLN_TGNumberEntry.tagnum = -1 ;
  G__G__GLLN_TGCheckButton.tagnum = -1 ;
  G__G__GLLN_TGColorSelect.tagnum = -1 ;
  G__G__GLLN_TGL5DPainter.tagnum = -1 ;
  G__G__GLLN_TGListBox.tagnum = -1 ;
  G__G__GLLN_TGHSlider.tagnum = -1 ;
  G__G__GLLN_TGL5DDataSetEditor.tagnum = -1 ;
  G__G__GLLN_TGL5DDataSetEditorcLcLTGL5DEditorPrivate.tagnum = -1 ;
  G__G__GLLN_TF1.tagnum = -1 ;
  G__G__GLLN_TVirtualHistPainter.tagnum = -1 ;
  G__G__GLLN_TGLParametricEquation.tagnum = -1 ;
  G__G__GLLN_TGLTH3Composition.tagnum = -1 ;
  G__G__GLLN_TGLHistPainter.tagnum = -1 ;
  G__G__GLLN_auto_ptrlETVirtualHistPaintergR.tagnum = -1 ;
  G__G__GLLN_auto_ptrlETGLPlotPaintergR.tagnum = -1 ;
  G__G__GLLN_TGLHistPaintercLcLPlotOption_t.tagnum = -1 ;
  G__G__GLLN_TAttAxis.tagnum = -1 ;
  G__G__GLLN_TArray.tagnum = -1 ;
  G__G__GLLN_TTree.tagnum = -1 ;
  G__G__GLLN_TGL5DDataSetcLcLEdefaults.tagnum = -1 ;
  G__G__GLLN_auto_ptrlETGLHistPaintergR.tagnum = -1 ;
  G__G__GLLN_TGLAdapter.tagnum = -1 ;
  G__G__GLLN_TGLOvlSelectRecord.tagnum = -1 ;
  G__G__GLLN_TGLOverlayElement.tagnum = -1 ;
  G__G__GLLN_TGLOverlayElementcLcLERole.tagnum = -1 ;
  G__G__GLLN_TGLOverlayElementcLcLEState.tagnum = -1 ;
  G__G__GLLN_TGLOverlayList.tagnum = -1 ;
  G__G__GLLN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_FTFont.tagnum = -1 ;
  G__G__GLLN_TGLFontManager.tagnum = -1 ;
  G__G__GLLN_TGLFont.tagnum = -1 ;
  G__G__GLLN_TGLFontcLcLEMode.tagnum = -1 ;
  G__G__GLLN_TGLFontcLcLETextAlignH_e.tagnum = -1 ;
  G__G__GLLN_TGLFontcLcLETextAlignV_e.tagnum = -1 ;
  G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_TGLViewerBase.tagnum = -1 ;
  G__G__GLLN_TGTextEdit.tagnum = -1 ;
  G__G__GLLN_TGLAnnotation.tagnum = -1 ;
  G__G__GLLN_TGLAnnotationcLcLEDrag.tagnum = -1 ;
  G__G__GLLN_TGLAnnotationcLcLENameStack.tagnum = -1 ;
  G__G__GLLN_TStopwatch.tagnum = -1 ;
  G__G__GLLN_TGLAutoRotator.tagnum = -1 ;
  G__G__GLLN_TGLText.tagnum = -1 ;
  G__G__GLLN_TGLAxis.tagnum = -1 ;
  G__G__GLLN_TPMERegexp.tagnum = -1 ;
  G__G__GLLN_TGLAxisPainter.tagnum = -1 ;
  G__G__GLLN_pairlEfloatcOfloatgR.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_pairlEfloatcOintgR.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLAxisPainterBox.tagnum = -1 ;
  G__G__GLLN_GLUquadric.tagnum = -1 ;
  G__G__GLLN_TGLBoxPainter.tagnum = -1 ;
  G__G__GLLN_TGLBoxPaintercLcLEBoxType.tagnum = -1 ;
  G__G__GLLN_TGLCameraGuide.tagnum = -1 ;
  G__G__GLLN_TGLCameracLcLEFrustumPlane.tagnum = -1 ;
  G__G__GLLN_TGLCameraOverlay.tagnum = -1 ;
  G__G__GLLN_TGLCameraOverlaycLcLEMode.tagnum = -1 ;
  G__G__GLLN_TGLPShapeRef.tagnum = -1 ;
  G__G__GLLN_TGLPhysicalShapecLcLEManip.tagnum = -1 ;
  G__G__GLLN_TGLManipSet.tagnum = -1 ;
  G__G__GLLN_TGLClip.tagnum = -1 ;
  G__G__GLLN_TGLClipcLcLEMode.tagnum = -1 ;
  G__G__GLLN_TGLClipPlane.tagnum = -1 ;
  G__G__GLLN_TGLClipBox.tagnum = -1 ;
  G__G__GLLN_TGLClipSet.tagnum = -1 ;
  G__G__GLLN_TGButton.tagnum = -1 ;
  G__G__GLLN_TGButtonGroup.tagnum = -1 ;
  G__G__GLLN_TGLClipSetSubEditor.tagnum = -1 ;
  G__G__GLLN_TGLClipSetEditor.tagnum = -1 ;
  G__G__GLLN_TGLContextIdentity.tagnum = -1 ;
  G__G__GLLN_TGLFormatcLcLEFormatOptions.tagnum = -1 ;
  G__G__GLLN_TGLContextPrivate.tagnum = -1 ;
  G__G__GLLN_TGLWidget.tagnum = -1 ;
  G__G__GLLN_pairlEunsignedsPintcOintgR.tagnum = -1 ;
  G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_listlETGLContextmUcOallocatorlETGLContextmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_TBuffer3DTube.tagnum = -1 ;
  G__G__GLLN_TGLCylinder.tagnum = -1 ;
  G__G__GLLN_TGLLockable.tagnum = -1 ;
  G__G__GLLN_TGLLockablecLcLELock.tagnum = -1 ;
  G__G__GLLN_TGLSceneInfo.tagnum = -1 ;
  G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR.tagnum = -1 ;
  G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLStopwatch.tagnum = -1 ;
  G__G__GLLN_TGLSelectBuffer.tagnum = -1 ;
  G__G__GLLN_TGLRnrCtxcLcLEStyle.tagnum = -1 ;
  G__G__GLLN_TGLRnrCtxcLcLEPass.tagnum = -1 ;
  G__G__GLLN_TGLRnrCtxcLcLELODPresets.tagnum = -1 ;
  G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel.tagnum = -1 ;
  G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_TGLSelectRecordBase.tagnum = -1 ;
  G__G__GLLN_TGLSelectRecordcLcLESecSelResult.tagnum = -1 ;
  G__G__GLLN_TBuffer3DSphere.tagnum = -1 ;
  G__G__GLLN_TGLPerspectiveCamera.tagnum = -1 ;
  G__G__GLLN_TGLOrthoCamera.tagnum = -1 ;
  G__G__GLLN_TGLOrthoCameracLcLEType.tagnum = -1 ;
  G__G__GLLN_TGEventHandler.tagnum = -1 ;
  G__G__GLLN_TGLRedrawTimer.tagnum = -1 ;
  G__G__GLLN_TGLViewerEditor.tagnum = -1 ;
  G__G__GLLN_TGLLightSet.tagnum = -1 ;
  G__G__GLLN_TGLPShapeObj.tagnum = -1 ;
  G__G__GLLN_TGLOutput.tagnum = -1 ;
  G__G__GLLN_TGLEventHandler.tagnum = -1 ;
  G__G__GLLN_TGLViewercLcLECameraType.tagnum = -1 ;
  G__G__GLLN_TGLViewercLcLESecSelType.tagnum = -1 ;
  G__G__GLLN_TGLViewercLcLEPushAction.tagnum = -1 ;
  G__G__GLLN_TGLViewercLcLEDragAction.tagnum = -1 ;
  G__G__GLLN_TGLFaderHelper.tagnum = -1 ;
  G__G__GLLN_TGLEmbeddedViewer.tagnum = -1 ;
  G__G__GLLN_RootCsg.tagnum = -1 ;
  G__G__GLLN_RootCsgcLcLTBaseMesh.tagnum = -1 ;
  G__G__GLLN_TGLFaceSet.tagnum = -1 ;
  G__G__GLLN_TGLFBO.tagnum = -1 ;
  G__G__GLLN_TGLPadPainter.tagnum = -1 ;
  G__G__GLLN_RglcLcLPad.tagnum = -1 ;
  G__G__GLLN_RglcLcLPadcLcLPolygonStippleSet.tagnum = -1 ;
  G__G__GLLN_RglcLcLPadcLcLMarkerPainter.tagnum = -1 ;
  G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETPointcOallocatorlETPointgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_listlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgR.tagnum = -1 ;
  G__G__GLLN_RglcLcLPadcLcLTesselator.tagnum = -1 ;
  G__G__GLLN_RglcLcLPadcLcLGLLimits.tagnum = -1 ;
  G__G__GLLN_TMultiGraph.tagnum = -1 ;
  G__G__GLLN_TGraph.tagnum = -1 ;
  G__G__GLLN_TGLH2PolyPainter.tagnum = -1 ;
  G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_TGLLegoPainter.tagnum = -1 ;
  G__G__GLLN_TGLLegoPaintercLcLELegoType.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLLightSetSubEditor.tagnum = -1 ;
  G__G__GLLN_TGLLightSetEditor.tagnum = -1 ;
  G__G__GLLN_TGLLightSetcLcLELight.tagnum = -1 ;
  G__G__GLLN_TGLManipSetcLcLEManip.tagnum = -1 ;
  G__G__GLLN_TGLOutputcLcLEFormat.tagnum = -1 ;
  G__G__GLLN_TGLOverlayButton.tagnum = -1 ;
  G__G__GLLN_TVirtualPadPainter.tagnum = -1 ;
  G__G__GLLN_TVirtualPadPaintercLcLEBoxMode.tagnum = -1 ;
  G__G__GLLN_TVirtualPadPaintercLcLETextMode.tagnum = -1 ;
  G__G__GLLN_TGLParametricEquationGL.tagnum = -1 ;
  G__G__GLLN_auto_ptrlETF2gR.tagnum = -1 ;
  G__G__GLLN_TGLParametricPlot.tagnum = -1 ;
  G__G__GLLN_TGLParametricPlotcLcLEMeshSize.tagnum = -1 ;
  G__G__GLLN_TGL2DArraylETGLParametricPlotcLcLVertex_tgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLPolyLine.tagnum = -1 ;
  G__G__GLLN_TGLPolyMarker.tagnum = -1 ;
  G__G__GLLN_TGRadioButton.tagnum = -1 ;
  G__G__GLLN_TGLPShapeObjEditor.tagnum = -1 ;
  G__G__GLLN_TGLPShapeObjEditorcLcLELightMode.tagnum = -1 ;
  G__G__GLLN_TGLRotateManip.tagnum = -1 ;
  G__G__GLLN_TGLSAViewer.tagnum = -1 ;
  G__G__GLLN_TGLSAFrame.tagnum = -1 ;
  G__G__GLLN_TGPopupMenu.tagnum = -1 ;
  G__G__GLLN_TGMenuBar.tagnum = -1 ;
  G__G__GLLN_TGLSAViewercLcLEGLSACommands.tagnum = -1 ;
  G__G__GLLN_TGLScaleManip.tagnum = -1 ;
  G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgR.tagnum = -1 ;
  G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_TGLSceneInfocLcLEClipTest.tagnum = -1 ;
  G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_pairlETObjectmUcOTGLLogicalShapemUgR.tagnum = -1 ;
  G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_pairlEunsignedsPintcOTGLPhysicalShapemUgR.tagnum = -1 ;
  G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_TGLScenecLcLDrawElement_t.tagnum = -1 ;
  G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR.tagnum = -1 ;
  G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLScenecLcLTSceneInfo.tagnum = -1 ;
  G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_TGLScenePad.tagnum = -1 ;
  G__G__GLLN_pairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgR.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_pairlEunsignedsPintcOunsignedsPintmUgR.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLSphere.tagnum = -1 ;
  G__G__GLLN_TRandom.tagnum = -1 ;
  G__G__GLLN_TGLSurfacePainter.tagnum = -1 ;
  G__G__GLLN_TGLSurfacePaintercLcLESurfaceType.tagnum = -1 ;
  G__G__GLLN_TGL2DArraylETGLVertex3gR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLVertex3cOallocatorlETGLVertex3gRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLVertex3cOallocatorlETGLVertex3gRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGL2DArraylEpairlETGLVector3cOTGLVector3gRsPgR.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGL2DArraylETGLVector3gR.tagnum = -1 ;
  G__G__GLLN_vectorlETGLVector3cOallocatorlETGLVector3gRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlETGLVector3cOallocatorlETGLVector3gRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLSurfacePaintercLcLProjection_t.tagnum = -1 ;
  G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR.tagnum = -1 ;
  G__G__GLLN_RglcLcLMc.tagnum = -1 ;
  G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLTF3Painter.tagnum = -1 ;
  G__G__GLLN_TGLTF3PaintercLcLETF3Style.tagnum = -1 ;
  G__G__GLLN_RglcLcLMccLcLTIsoMeshlEdoublegR.tagnum = -1 ;
  G__G__GLLN_TGLIsoPainter.tagnum = -1 ;
  G__G__GLLN_RglcLcLMccLcLTIsoMeshlEfloatgR.tagnum = -1 ;
  G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__GLLN_TArrayC.tagnum = -1 ;
  G__G__GLLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__GLLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__GLLN_TAtt3D.tagnum = -1 ;
  G__G__GLLN_TH3C.tagnum = -1 ;
  G__G__GLLN_TGLTH3CompositionPainter.tagnum = -1 ;
  G__G__GLLN_TGLTH3CompositioncLcLETH3BinShape.tagnum = -1 ;
  G__G__GLLN_pairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegR.tagnum = -1 ;
  G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR.tagnum = -1 ;
  G__G__GLLN_reverse_iteratorlEvectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__GLLN_TGLTransManip.tagnum = -1 ;
  G__G__GLLN_TGComboBox.tagnum = -1 ;
  G__G__GLLN_pairlEvoidmUcOvoidmUgR.tagnum = -1 ;
  G__G__GLLN_setlETGLContextmUcOlesslETGLContextmUgRcOallocatorlETGLContextmUgRsPgR.tagnum = -1 ;
  G__G__GLLN_TH2GL.tagnum = -1 ;
  G__G__GLLN_TH3GL.tagnum = -1 ;
  G__G__GLLN_TPointSet3DGL.tagnum = -1 ;
  G__G__GLLN_TX11GLManager.tagnum = -1 ;
  G__G__GLLN_TX11GLManagercLcLTX11GLImpl.tagnum = -1 ;
  G__G__GLLN_TX11GLManagercLcLTGLContext_t.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__GL() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__GLLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TString);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TList);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TTimer);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TPoint);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TArcBall),sizeof(TArcBall),-1,3840,"ArcBall manipulator",G__setup_memvarTArcBall,G__setup_memfuncTArcBall);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLBoundingBox),sizeof(TGLBoundingBox),-1,36608,"a 3D orientated bounding box",G__setup_memvarTGLBoundingBox,G__setup_memfuncTGLBoundingBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLCamera),sizeof(TGLCamera),-1,36614,"Camera abstract base class.",G__setup_memvarTGLCamera,G__setup_memfuncTGLCamera);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__GLLN_GLUtesselator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_EOverlap);
   G__get_linked_tagnum_fwd(&G__G__GLLN_EClipType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_EGLCoordType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_EGLPlotType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLVector3),sizeof(TGLVector3),-1,36608,"GL 3 component vector helper/wrapper class",G__setup_memvarTGLVector3,G__setup_memfuncTGLVector3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLVertex3),sizeof(TGLVertex3),-1,36608,"GL 3 component vertex helper/wrapper class",G__setup_memvarTGLVertex3,G__setup_memfuncTGLVertex3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLine3),sizeof(TGLLine3),-1,33792,"GL line wrapper class",G__setup_memvarTGLLine3,G__setup_memfuncTGLLine3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRect),sizeof(TGLRect),-1,34048,"GL rect helper/wrapper class",G__setup_memvarTGLRect,G__setup_memfuncTGLRect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlane),sizeof(TGLPlane),-1,34560,"GL plane helper/wrapper class",G__setup_memvarTGLPlane,G__setup_memfuncTGLPlane);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEboolcOTGLLine3gR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEboolcOTGLVertex3gR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLMatrix),sizeof(TGLMatrix),-1,36608,"GL matrix helper/wrapper class",G__setup_memvarTGLMatrix,G__setup_memfuncTGLMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLColor),sizeof(TGLColor),-1,36096,"Color in preferred GL format - RGBA.",G__setup_memvarTGLColor,G__setup_memfuncTGLColor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLColorSet),sizeof(TGLColorSet),-1,3328,"Collection of colors used for GL rendering.",G__setup_memvarTGLColorSet,G__setup_memfuncTGLColorSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLUtil),sizeof(TGLUtil),-1,3584,"Wrapper class for misc GL pieces",G__setup_memvarTGLUtil,G__setup_memfuncTGLUtil);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLUtilcLcLTColorLocker),sizeof(TGLUtil::TColorLocker),-1,1280,"Lock/unlock color in constructor/destructor.",G__setup_memvarTGLUtilcLcLTColorLocker,G__setup_memfuncTGLUtilcLcLTColorLocker);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLUtilcLcLTDrawQualityModifier),sizeof(TGLUtil::TDrawQualityModifier),-1,33792,"Set/restore draw quality in constructor/destructor.",G__setup_memvarTGLUtilcLcLTDrawQualityModifier,G__setup_memfuncTGLUtilcLcLTDrawQualityModifier);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLUtilcLcLTDrawQualityScaler),sizeof(TGLUtil::TDrawQualityScaler),-1,33792,"Multiply/restore draw quality in constructor/destructor.",G__setup_memvarTGLUtilcLcLTDrawQualityScaler,G__setup_memfuncTGLUtilcLcLTDrawQualityScaler);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLUtilcLcLELineHeadShape);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLUtilcLcLEAxesType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSelectionBuffer),sizeof(TGLSelectionBuffer),-1,3840,"Holds color buffer content for selection",G__setup_memvarTGLSelectionBuffer,G__setup_memfuncTGLSelectionBuffer);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlotCoordinates),sizeof(TGLPlotCoordinates),-1,3840,"Auxilary class, holds plot dimensions.",G__setup_memvarTGLPlotCoordinates,G__setup_memfuncTGLPlotCoordinates);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLQuadric),sizeof(TGLQuadric),-1,3840,"GL quadric object",G__setup_memvarTGLQuadric,G__setup_memfuncTGLQuadric);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAxis);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_Rgl),0,-1,0,(char*)NULL,G__setup_memvarRgl,G__setup_memfuncRgl);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEintcOintgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEdoublecOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLevelPalette);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLBoundingBoxcLcLEFace);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TBuffer3D);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TContextMenu);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPhysicalShape),sizeof(TGLPhysicalShape),-1,36352,"a physical (placed, global frame) drawable object",G__setup_memvarTGLPhysicalShape,G__setup_memfuncTGLPhysicalShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRnrCtx),sizeof(TGLRnrCtx),-1,298496,"Collection of objects and data passes along all rendering calls.",G__setup_memvarTGLRnrCtx,G__setup_memfuncTGLRnrCtx);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSelectRecord),sizeof(TGLSelectRecord),-1,298752,"Standard GL selection record.",G__setup_memvarTGLSelectRecord,G__setup_memfuncTGLSelectRecord);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewer),sizeof(TGLViewer),-1,327168,"Standard ROOT GL viewer.",G__setup_memvarTGLViewer,G__setup_memfuncTGLViewer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSceneBase),sizeof(TGLSceneBase),-1,265985,"Base-class for OpenGL scenes.",G__setup_memvarTGLSceneBase,G__setup_memfuncTGLSceneBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLScene),sizeof(TGLScene),-1,265984,"Standard ROOT OpenGL scene with logial/physical shapes.",G__setup_memvarTGLScene,G__setup_memfuncTGLScene);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLogicalShape),sizeof(TGLLogicalShape),-1,36609,"a logical (non-placed, local frame) drawable object",G__setup_memvarTGLLogicalShape,G__setup_memfuncTGLLogicalShape);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLogicalShapecLcLELODAxes);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TMap);
   G__get_linked_tagnum_fwd(&G__G__GLLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLObject),sizeof(TGLObject),-1,296195,"Base-class for direct OpenGL renderers",G__setup_memvarTGLObject,G__setup_memfuncTGLObject);
   G__get_linked_tagnum_fwd(&G__G__GLLN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualViewer3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLManip),sizeof(TGLManip),-1,36609,"abstract base GL manipulator widget",G__setup_memvarTGLManip,G__setup_memfuncTGLManip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualGLPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualGLManip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLContext),sizeof(TGLContext),-1,36352,"Control internal gl-context resources.",G__setup_memvarTGLContext,G__setup_memfuncTGLContext);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFormat),sizeof(TGLFormat),-1,34048,"Describes GL buffer format.",G__setup_memvarTGLFormat,G__setup_memfuncTGLFormat);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPaintDevice);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TColor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlotBox),sizeof(TGLPlotBox),-1,33792,"Back box for plot.",G__setup_memvarTGLPlotBox,G__setup_memfuncTGLPlotBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlotCamera),sizeof(TGLPlotCamera),-1,265984,"Camera for plot-painters.",G__setup_memvarTGLPlotCamera,G__setup_memfuncTGLPlotCamera);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGL5DDataSet),sizeof(TGL5DDataSet),-1,64000,"Class to read data from TTree and create TGL5DPainter.",G__setup_memvarTGL5DDataSet,G__setup_memfuncTGL5DDataSet);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TH1);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TH3);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TF3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLBoxCut),sizeof(TGLBoxCut),-1,33792,"Cuts away part of a plot.",G__setup_memvarTGLBoxCut,G__setup_memfuncTGLBoxCut);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTH3Slice),sizeof(TGLTH3Slice),-1,61440,"TH3 slice",G__setup_memvarTGLTH3Slice,G__setup_memfuncTGLTH3Slice);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTH3SlicecLcLESliceAxis);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL2DArraylEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlotPainter),sizeof(TGLPlotPainter),-1,32780,"Base for gl plots",G__setup_memvarTGLPlotPainter,G__setup_memfuncTGLPlotPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlotPaintercLcLESelectionBase);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlotPaintercLcLECutAxisID);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TH2Poly);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualPad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPlot3D),sizeof(TGLPlot3D),-1,298755,"Short description.",G__setup_memvarTGLPlot3D,G__setup_memfuncTGLPlot3D);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TF2);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TH2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TF2GL),sizeof(TF2GL),-1,298752,"GL renderer for TF2 and TF3.",G__setup_memvarTF2GL,G__setup_memfuncTF2GL);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGWindow);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAttText);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGTextButton);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGVerticalFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGGroupFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGToolTip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGedEditor);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGedFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGNumberEntryField);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGDoubleHSlider);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGNumberEntry);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGCheckButton);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGColorSelect);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL5DPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGListBox);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGHSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGL5DDataSetEditor),sizeof(TGL5DDataSetEditor),-1,65280,"GUI for editing OpenGL 5D Viewer attributes",G__setup_memvarTGL5DDataSetEditor,G__setup_memfuncTGL5DDataSetEditor);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL5DDataSetEditorcLcLTGL5DEditorPrivate);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TF1);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualHistPainter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLParametricEquation),sizeof(TGLParametricEquation),-1,64000,"Equation of parametric surface.",G__setup_memvarTGLParametricEquation,G__setup_memfuncTGLParametricEquation);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTH3Composition),sizeof(TGLTH3Composition),-1,64256,"Composition of TH3 objects.",G__setup_memvarTGLTH3Composition,G__setup_memfuncTGLTH3Composition);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLHistPainter),sizeof(TGLHistPainter),-1,64000,"Proxy class for GL hist painters.",G__setup_memvarTGLHistPainter,G__setup_memfuncTGLHistPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_auto_ptrlETVirtualHistPaintergR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_auto_ptrlETGLPlotPaintergR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLHistPaintercLcLPlotOption_t);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAttAxis);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TArray);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TTree);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL5DDataSetcLcLEdefaults);
   G__get_linked_tagnum_fwd(&G__G__GLLN_auto_ptrlETGLHistPaintergR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAdapter),sizeof(TGLAdapter),-1,2816,"Allow plot-painters to be used for gl-inpad and gl-viewer.",G__setup_memvarTGLAdapter,G__setup_memfuncTGLAdapter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOvlSelectRecord),sizeof(TGLOvlSelectRecord),-1,298752,"Standard GL overlay-selection record.",G__setup_memvarTGLOvlSelectRecord,G__setup_memfuncTGLOvlSelectRecord);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOverlayElement),sizeof(TGLOverlayElement),-1,265985,"Base class for GL overlay elements.",G__setup_memvarTGLOverlayElement,G__setup_memfuncTGLOverlayElement);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOverlayElementcLcLERole);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOverlayElementcLcLEState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOverlayList),sizeof(TGLOverlayList),-1,265984,"Collection of overlay elements to draw/select together.",G__setup_memvarTGLOverlayList,G__setup_memfuncTGLOverlayList);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_FTFont);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFontManager),sizeof(TGLFontManager),-1,3840,"A FreeType GL font manager.",G__setup_memvarTGLFontManager,G__setup_memfuncTGLFontManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFont),sizeof(TGLFont),-1,36608,"A wrapper class for FTFont.",G__setup_memvarTGLFont,G__setup_memfuncTGLFont);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFontcLcLEMode);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFontcLcLETextAlignH_e);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFontcLcLETextAlignV_e);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewerBase),sizeof(TGLViewerBase),-1,265984,"GL Viewer base-class.",G__setup_memvarTGLViewerBase,G__setup_memfuncTGLViewerBase);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGTextEdit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAnnotation),sizeof(TGLAnnotation),-1,298496,"GL-annotation.",G__setup_memvarTGLAnnotation,G__setup_memfuncTGLAnnotation);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAnnotationcLcLEDrag);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAnnotationcLcLENameStack);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TStopwatch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAutoRotator),sizeof(TGLAutoRotator),-1,327168,"Short description.",G__setup_memvarTGLAutoRotator,G__setup_memfuncTGLAutoRotator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLText),sizeof(TGLText),-1,36608,"a GL text",G__setup_memvarTGLText,G__setup_memfuncTGLText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAxis),sizeof(TGLAxis),-1,36608,"a GL Axis",G__setup_memvarTGLAxis,G__setup_memfuncTGLAxis);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TPMERegexp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAxisPainter),sizeof(TGLAxisPainter),-1,265984,"GL axis painter.",G__setup_memvarTGLAxisPainter,G__setup_memfuncTGLAxisPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEfloatcOfloatgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEfloatcOintgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLAxisPainterBox),sizeof(TGLAxisPainterBox),-1,263424,"Painter of GL axes for a 3D box.",G__setup_memvarTGLAxisPainterBox,G__setup_memfuncTGLAxisPainterBox);
   G__get_linked_tagnum_fwd(&G__G__GLLN_GLUquadric);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLBoxPainter),sizeof(TGLBoxPainter),-1,35328,"Box painter",G__setup_memvarTGLBoxPainter,G__setup_memfuncTGLBoxPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLBoxPaintercLcLEBoxType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLCameraGuide),sizeof(TGLCameraGuide),-1,36352,"Short description.",G__setup_memvarTGLCameraGuide,G__setup_memfuncTGLCameraGuide);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLCameracLcLEFrustumPlane);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLCameraOverlay),sizeof(TGLCameraOverlay),-1,3840,"Show coorinates of current camera frustum.",G__setup_memvarTGLCameraOverlay,G__setup_memfuncTGLCameraOverlay);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLCameraOverlaycLcLEMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPShapeRef),sizeof(TGLPShapeRef),-1,298752,"Reference to a TGLPhysicalShape object.",G__setup_memvarTGLPShapeRef,G__setup_memfuncTGLPShapeRef);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPhysicalShapecLcLEManip);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLManipSet),sizeof(TGLManipSet),-1,36608,"A collection of available manipulators.",G__setup_memvarTGLManipSet,G__setup_memfuncTGLManipSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClip),sizeof(TGLClip),-1,295938,"abstract clipping object",G__setup_memvarTGLClip,G__setup_memfuncTGLClip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClipcLcLEMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClipPlane),sizeof(TGLClipPlane),-1,296192,"clipping plane",G__setup_memvarTGLClipPlane,G__setup_memfuncTGLClipPlane);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClipBox),sizeof(TGLClipBox),-1,296192,"clipping box",G__setup_memvarTGLClipBox,G__setup_memfuncTGLClipBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClipSet),sizeof(TGLClipSet),-1,265984,"A collection of supported clip-objects",G__setup_memvarTGLClipSet,G__setup_memfuncTGLClipSet);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGButton);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGButtonGroup);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClipSetSubEditor),sizeof(TGLClipSetSubEditor),-1,327168,"Sub-editor for TGLClipSet.",G__setup_memvarTGLClipSetSubEditor,G__setup_memfuncTGLClipSetSubEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLClipSetEditor),sizeof(TGLClipSetEditor),-1,327424,"GUI editor for TGLClipSet.",G__setup_memvarTGLClipSetEditor,G__setup_memfuncTGLClipSetEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLContextIdentity),sizeof(TGLContextIdentity),-1,1280,"Identity of a shared GL context.",G__setup_memvarTGLContextIdentity,G__setup_memfuncTGLContextIdentity);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFormatcLcLEFormatOptions);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLContextPrivate);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLWidget),sizeof(TGLWidget),-1,65024,"Window (widget) version of TGLPaintDevice",G__setup_memvarTGLWidget,G__setup_memfuncTGLWidget);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEunsignedsPintcOintgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLContextmUcOallocatorlETGLContextmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TBuffer3DTube);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLCylinder),sizeof(TGLCylinder),-1,33792,"a cylinderical logical shape",G__setup_memvarTGLCylinder,G__setup_memfuncTGLCylinder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLockable),sizeof(TGLLockable),-1,3840,"Lock for viewers and scenes.",G__setup_memvarTGLLockable,G__setup_memfuncTGLLockable);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLockablecLcLELock);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSceneInfo),sizeof(TGLSceneInfo),-1,265984,"Data about a scene within a viewer context.",G__setup_memvarTGLSceneInfo,G__setup_memfuncTGLSceneInfo);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLSceneInfomUcOallocatorlETGLSceneInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLStopwatch),sizeof(TGLStopwatch),-1,1280,"a GL stopwatch utility class",G__setup_memvarTGLStopwatch,G__setup_memfuncTGLStopwatch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSelectBuffer),sizeof(TGLSelectBuffer),-1,263424,"OpenGL select buffer with depth sorting.",G__setup_memvarTGLSelectBuffer,G__setup_memfuncTGLSelectBuffer);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRnrCtxcLcLEStyle);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRnrCtxcLcLEPass);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRnrCtxcLcLELODPresets);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRnrCtxcLcLEShapeSelectionLevel);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLColorSetmUcOallocatorlETGLColorSetmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSelectRecordBase),sizeof(TGLSelectRecordBase),-1,298752,"Base class for GL selection records.",G__setup_memvarTGLSelectRecordBase,G__setup_memfuncTGLSelectRecordBase);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSelectRecordcLcLESecSelResult);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TBuffer3DSphere);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPerspectiveCamera),sizeof(TGLPerspectiveCamera),-1,33792,"Camera for perspective view.",G__setup_memvarTGLPerspectiveCamera,G__setup_memfuncTGLPerspectiveCamera);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOrthoCamera),sizeof(TGLOrthoCamera),-1,33792,"Camera for orthographic view.",G__setup_memvarTGLOrthoCamera,G__setup_memfuncTGLOrthoCamera);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOrthoCameracLcLEType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGEventHandler);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRedrawTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewerEditor),sizeof(TGLViewerEditor),-1,327424,"GUI for editing TGLViewer attributes",G__setup_memvarTGLViewerEditor,G__setup_memfuncTGLViewerEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLightSet),sizeof(TGLLightSet),-1,294656,"A set of OpenGL lights.",G__setup_memvarTGLLightSet,G__setup_memfuncTGLLightSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPShapeObj),sizeof(TGLPShapeObj),-1,327424,"This object wraps TGLPhysicalShape (not a TObject)",G__setup_memvarTGLPShapeObj,G__setup_memfuncTGLPShapeObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOutput),sizeof(TGLOutput),-1,1024,"Wrapper class for GL capture & output routines",G__setup_memvarTGLOutput,G__setup_memfuncTGLOutput);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLEventHandler),sizeof(TGLEventHandler),-1,62464,"Base-class and default implementation of event-handler for TGLViewer.",G__setup_memvarTGLEventHandler,G__setup_memfuncTGLEventHandler);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewercLcLECameraType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewercLcLESecSelType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewercLcLEPushAction);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLViewercLcLEDragAction);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFaderHelper),sizeof(TGLFaderHelper),-1,298752,(char*)NULL,G__setup_memvarTGLFaderHelper,G__setup_memfuncTGLFaderHelper);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLEmbeddedViewer),sizeof(TGLEmbeddedViewer),-1,65024,"Embedded GL viewer.",G__setup_memvarTGLEmbeddedViewer,G__setup_memfuncTGLEmbeddedViewer);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RootCsg);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RootCsgcLcLTBaseMesh);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFaceSet),sizeof(TGLFaceSet),-1,32768,"a faceset logical shape",G__setup_memvarTGLFaceSet,G__setup_memfuncTGLFaceSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLFBO),sizeof(TGLFBO),-1,265984,"Frame-buffer object.",G__setup_memvarTGLFBO,G__setup_memfuncTGLFBO);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPadPainter),sizeof(TGLPadPainter),-1,2816,(char*)NULL,G__setup_memvarTGLPadPainter,G__setup_memfuncTGLPadPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLPad);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLPadcLcLPolygonStippleSet);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLPadcLcLMarkerPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETPointcOallocatorlETPointgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETPointcOallocatorlETPointgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLPadcLcLTesselator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLPadcLcLGLLimits);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TMultiGraph);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLH2PolyPainter),sizeof(TGLH2PolyPainter),-1,32768,"Painter class for TH2Poly.",G__setup_memvarTGLH2PolyPainter,G__setup_memfuncTGLH2PolyPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRcOallocatorlElistlERglcLcLPadcLcLMeshPatch_tcOallocatorlERglcLcLPadcLcLMeshPatch_tgRsPgRsPgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLegoPainter),sizeof(TGLLegoPainter),-1,35328,"Lego painter",G__setup_memvarTGLLegoPainter,G__setup_memfuncTGLLegoPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLegoPaintercLcLELegoType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLightSetSubEditor),sizeof(TGLLightSetSubEditor),-1,327168,"Sub-editor for TGLLightSet.",G__setup_memvarTGLLightSetSubEditor,G__setup_memfuncTGLLightSetSubEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLightSetEditor),sizeof(TGLLightSetEditor),-1,327424,"Editor for TGLLightSet.",G__setup_memvarTGLLightSetEditor,G__setup_memfuncTGLLightSetEditor);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLLightSetcLcLELight);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLManipSetcLcLEManip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOutputcLcLEFormat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLOverlayButton),sizeof(TGLOverlayButton),-1,298496,"GL-overlay button.",G__setup_memvarTGLOverlayButton,G__setup_memfuncTGLOverlayButton);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualPadPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualPadPaintercLcLEBoxMode);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVirtualPadPaintercLcLETextMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLParametricEquationGL),sizeof(TGLParametricEquationGL),-1,36608,"GL renderer for TGLParametricEquation",G__setup_memvarTGLParametricEquationGL,G__setup_memfuncTGLParametricEquationGL);
   G__get_linked_tagnum_fwd(&G__G__GLLN_auto_ptrlETF2gR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLParametricPlot),sizeof(TGLParametricPlot),-1,35328,"Parametric plot's painter.",G__setup_memvarTGLParametricPlot,G__setup_memfuncTGLParametricPlot);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLParametricPlotcLcLEMeshSize);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL2DArraylETGLParametricPlotcLcLVertex_tgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLParametricPlotcLcLVertex_tcOallocatorlETGLParametricPlotcLcLVertex_tgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPolyLine),sizeof(TGLPolyLine),-1,32768,"a polyline logical shape",G__setup_memvarTGLPolyLine,G__setup_memfuncTGLPolyLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPolyMarker),sizeof(TGLPolyMarker),-1,32768,"a polymarker logical shape",G__setup_memvarTGLPolyMarker,G__setup_memfuncTGLPolyMarker);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGRadioButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPShapeObjEditor),sizeof(TGLPShapeObjEditor),-1,324864,"GUI for editing attributes of a physical-shape.",G__setup_memvarTGLPShapeObjEditor,G__setup_memfuncTGLPShapeObjEditor);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLPShapeObjEditorcLcLELightMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLRotateManip),sizeof(TGLRotateManip),-1,34048,"GL rotation manipulator widget",G__setup_memvarTGLRotateManip,G__setup_memfuncTGLRotateManip);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSAViewer),sizeof(TGLSAViewer),-1,65024,"Standalone GL viewer.",G__setup_memvarTGLSAViewer,G__setup_memfuncTGLSAViewer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSAFrame),sizeof(TGLSAFrame),-1,65024,"GUI frame for standalone viewer",G__setup_memvarTGLSAFrame,G__setup_memfuncTGLSAFrame);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGPopupMenu);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGMenuBar);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSAViewercLcLEGLSACommands);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLScaleManip),sizeof(TGLScaleManip),-1,34048,"GL scaling manipulator widget",G__setup_memvarTGLScaleManip,G__setup_memfuncTGLScaleManip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLViewerBasemUcOallocatorlETGLViewerBasemUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSceneInfocLcLEClipTest);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlETObjectmUcOTGLLogicalShapemUgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplETObjectmUcOTGLLogicalShapemUcOlesslETObjectmUgRcOallocatorlEpairlETObjectmUsPconstcOTGLLogicalShapemUgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEunsignedsPintcOTGLPhysicalShapemUgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplEunsignedsPintcOTGLPhysicalShapemUcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOTGLPhysicalShapemUgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLScenecLcLDrawElement_t);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tcOallocatorlETGLScenecLcLDrawElement_tgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLScenecLcLDrawElement_tmUcOallocatorlETGLScenecLcLDrawElement_tmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEconstsPTGLPhysicalShapemUcOallocatorlEconstsPTGLPhysicalShapemUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLScenecLcLTSceneInfo),sizeof(TGLScene::TSceneInfo),-1,263424,(char*)NULL,G__setup_memvarTGLScenecLcLTSceneInfo,G__setup_memfuncTGLScenecLcLTSceneInfo);
   G__get_linked_tagnum_fwd(&G__G__GLLN_maplETClassmUcOunsignedsPintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOunsignedsPintgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLScenePad),sizeof(TGLScenePad),-1,327168,"GL-scene filled via TPad-TVirtualViewer interface.",G__setup_memvarTGLScenePad,G__setup_memfuncTGLScenePad);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRcOallocatorlEpairlEunsignedsPintcORootCsgcLcLTBaseMeshmUgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEunsignedsPintcOunsignedsPintmUgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintmUgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintmUgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSphere),sizeof(TGLSphere),-1,32768,"a spherical logical shape",G__setup_memvarTGLSphere,G__setup_memfuncTGLSphere);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TRandom);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSurfacePainter),sizeof(TGLSurfacePainter),-1,32768,"Surface painter.",G__setup_memvarTGLSurfacePainter,G__setup_memfuncTGLSurfacePainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSurfacePaintercLcLESurfaceType);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL2DArraylETGLVertex3gR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLVertex3cOallocatorlETGLVertex3gRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLVertex3cOallocatorlETGLVertex3gRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL2DArraylEpairlETGLVector3cOTGLVector3gRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlETGLVector3cOTGLVector3gRcOallocatorlEpairlETGLVector3cOTGLVector3gRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGL2DArraylETGLVector3gR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlETGLVector3cOallocatorlETGLVector3gRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlETGLVector3cOallocatorlETGLVector3gRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLSurfacePaintercLcLProjection_t);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlETGLSurfacePaintercLcLProjection_tcOallocatorlETGLSurfacePaintercLcLProjection_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLMc);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTF3Painter),sizeof(TGLTF3Painter),-1,32768,"GL TF3 painter.",G__setup_memvarTGLTF3Painter,G__setup_memfuncTGLTF3Painter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTF3PaintercLcLETF3Style);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLMccLcLTIsoMeshlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLIsoPainter),sizeof(TGLIsoPainter),-1,35328,"Iso option for TH3.",G__setup_memvarTGLIsoPainter,G__setup_memfuncTGLIsoPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_RglcLcLMccLcLTIsoMeshlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_listlERglcLcLMccLcLTIsoMeshlEfloatgRcOallocatorlERglcLcLMccLcLTIsoMeshlEfloatgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TArrayC);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TAtt3D);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TH3C);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTH3CompositionPainter),sizeof(TGLTH3CompositionPainter),-1,35328,"Painter to draw several TH3.",G__setup_memvarTGLTH3CompositionPainter,G__setup_memfuncTGLTH3CompositionPainter);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTH3CompositioncLcLETH3BinShape);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_vectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_reverse_iteratorlEvectorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRcOallocatorlEpairlEconstsPTH3mUcOTGLTH3CompositioncLcLETH3BinShapegRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TGLTransManip),sizeof(TGLTransManip),-1,34048,"GL translation manipulator widget",G__setup_memvarTGLTransManip,G__setup_memfuncTGLTransManip);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TGComboBox);
   G__get_linked_tagnum_fwd(&G__G__GLLN_pairlEvoidmUcOvoidmUgR);
   G__get_linked_tagnum_fwd(&G__G__GLLN_setlETGLContextmUcOlesslETGLContextmUgRcOallocatorlETGLContextmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TH2GL),sizeof(TH2GL),-1,298752,"GL renderer for TH2.",G__setup_memvarTH2GL,G__setup_memfuncTH2GL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TH3GL),sizeof(TH3GL),-1,298752,"GL renderer class for TH3.",G__setup_memvarTH3GL,G__setup_memfuncTH3GL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TPointSet3DGL),sizeof(TPointSet3DGL),-1,295168,"GL renderer for TPointSet3D",G__setup_memvarTPointSet3DGL,G__setup_memfuncTPointSet3DGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GLLN_TX11GLManager),sizeof(TX11GLManager),-1,65280,"X11-specific version of TGLManager",G__setup_memvarTX11GLManager,G__setup_memfuncTX11GLManager);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TX11GLManagercLcLTX11GLImpl);
   G__get_linked_tagnum_fwd(&G__G__GLLN_TX11GLManagercLcLTGLContext_t);
}
extern "C" void G__cpp_setupG__GL(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__GL()");
  G__set_cpp_environmentG__GL();
  G__cpp_setup_tagtableG__GL();

  G__cpp_setup_inheritanceG__GL();

  G__cpp_setup_typetableG__GL();

  G__cpp_setup_memvarG__GL();

  G__cpp_setup_memfuncG__GL();
  G__cpp_setup_globalG__GL();
  G__cpp_setup_funcG__GL();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__GL();
  return;
}
class G__cpp_setup_initG__GL {
  public:
    G__cpp_setup_initG__GL() { G__add_setup_func("G__GL",(G__incsetup)(&G__cpp_setupG__GL)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__GL() { G__remove_setup_func("G__GL"); }
};
G__cpp_setup_initG__GL G__cpp_setup_initializerG__GL;

---